DEV Community: Mustafif

Microsoft Recall - EW...

Mustafif — Wed, 29 May 2024 21:52:08 +0000

I am not much of a privacy freak; I don't mind targeted ads and the idea of corporations selling our data (as long as there is proper transparency); however, my bones shivered hearing this new Windows feature coming to Copilot plus PCS - Windows Recall.

Every 3 seconds, it will take a screenshot that can be used to learn how you use your PC and help you find things you previously went to. That's the paraphrasing of how it sort of works. The biggest issue is the screenshotting every 3 seconds—wtf!

First, Windows is already horrible at indexing regular files to search for something, so now it's going to use machine learning to try and search for anything you previously went to.

So for clarification, there is a blacklist of applications, and websites that you can configure, but what if a Windows update overrides it, or what if MOST Windows users aren't aware of it or don't configure anything! That's a huge privacy concern because if someone gains access to your PC, it makes their life so much easier; they don't even need your passwords anymore.

So...am I going to tell you to switch to Linux...no

The reason is that everyone uses their computer differently; as someone whose first application he opens up is a Terminal, Windows is already disgusting for me, and once I'm done school, it is dead to me; I already drive my desktop daily POP_OS!. However, it took me a while to become proficient in Linux's quirks, and not everyone's workflows will be able to perfectly translate to Linux.

My recommendation is to become aware of this new feature, be aware of these new "copilot plus" PCs being marketed, and if you want to switch, be ready to be open-minded and patient.

Check out my new Portfolio Website!

Mustafif — Tue, 09 Jan 2024 21:27:10 +0000

I created my own portfolio website which will contain an about me section, resume stuff (skills, experience), publications I've done, and a list of my articles from DevTo and my MoKa Reads Blog.

I hope to expand it as I continue to create more projects, research and curriculum development.

The website uses a custom web server created using the rocket crate along with tera templates for dynamic web pages.

I followed a minimalist style so I could easily have it look well on desktop and mobile.

You can check it all out at mustafif.com

MKProjects 2024 Shutdown

Mustafif — Thu, 07 Dec 2023 17:08:08 +0000

Starting this month I will begin working on migrating many of the MKProjects repositories to my personal account. The only repositories that will not be transferred, but instead will be managed under the MoKa Reads Foundation will be the following:

texcreate
texcreate-deb
texcweb
texcore
texcgen
texcreate_repo
texc_v3_sources
texc_v3_web
texcreate_v3_compiler_conf

The following repos will be deleted:

demo-repository
texcreate-templates
texcreate-backup
texcreate_old
DocumentationCreator
texcreate-local-web
texcreate.com
MaTeX
Tex-rs
Package_Manager
mkpm-rs
MKPM
MKProject_Books-CLI

As my focus becomes more towards MoKa Reads, a nonprofit organization that is built towards open education, with research, course development, opensourced publication, I will no longer to put much work with MKProjects.

I will replace it as a portfolio website with some domain with my name that will be aimed to have a personal touch.

For anyone who has supported MKProjects, I thank you all, and with TexCreate moving towards the MoKa Reads Foundation, I will be able to continue its mission to have LaTeX project easier for developers and students.

TexCreate v3.3 Initial Plans

Mustafif — Tue, 28 Nov 2023 01:53:51 +0000

I admittedly haven't had the chance to do much work on the TexCreate project these last few months, but its not like I haven't been using it, and because of that I do see things I would like to improve.

Firstly, I have not been able to work on adding extra templates to the MKProj first party templates. Next is changing the release system to Github releases and taking advantage of the .texcreate folder to be able to manage different releases, update, and stuff like that.

I do not have an exact timeline of when I'd be able to put this into reality, it will require abstractions to Github API, I'd have to also create a sort of package manager, and make changes to several crates.

To help support the future of this project, consider becoming a member at my store

TexCreate 3.2 Out! No MongoDB Tho?

Mustafif — Thu, 22 Jun 2023 02:56:49 +0000

I released TexCreate 3.2 with a few minor improvements relating to the alert that checks for new updates, which adds a timeout so you aren't checking forever and adding a feedback and donate commands to support the project better. However I also talked about 3.2 introducing a big overhaul of changes, why didn't it?

Well after thinking about it extensively, its a lot bigger of a migration than I had first expected. Such that I have to consider how I would support TexCreate 3.0-3.2 that use the Github release system and how I would migrate to MongoDB, so the answer will be by adding some type of abstraction through a new library called texcreate-db which will replace texcreate-repo.

The whole process will require a lot of planning and maybe won't be implemented until a few more TexCreate versions, so I decided I will implement it in a milestone fashion, as it will also work with my busy schedule where I'm finding it hard to give the project the much needed love it requires.

TexCreate 3.2 News

Mustafif — Wed, 07 Jun 2023 17:40:34 +0000

I haven't been working on TexCreate lately because the current 3.1 version works well without any significant issues with my daily writing. However, I have noticed a latency issue when finding updates, which causes me to use the --ignore true flag frequently. The Github release strategy could be more scalable, and I could not create a working database model that was simple for me to maintain.

While researching ways to centrally distribute my books, I came across MongoDB, and I was surprised at how easy it was to perform CRUD operations on a free database cluster. I am considering making improvements to notify users if they are waiting for new updates, allowing them to try reconnecting or ignore it after a specific timeout.

My next plan is to release TexCreate templates v4, which will include four more templates, and I plan on migrating my current release system to MongoDB. This will require a refactor; I don't expect this release to be ready for a few months. However, I am excited about the scalability and performance improvements this change promises to bring.

A Little Panic in Zig

Mustafif — Thu, 01 Jun 2023 22:21:03 +0000

In Rust there are several ways to handle errors that come from the Result and Option types. A common way to get the inner value is using the unwrap method that either returns the value or panics the program. So how would we implement this function in Zig? Well there are several methods of handling errors in Zig, to keep ours simple we will use an if/else statement.

Let's start with by creating a file called unwrap.zig, and import the standard library and assign it to the constant std.

// unwrap.zig 
const std = @import("std");

We will be using compile time generics in our function, you may also use function type inference if you'd like.

What we expect is a type for our generic T, and an error set in the form anyerror!T where we will return the value T.

pub fn unwrap(comptime T: type, val: anyerror!T) T {}

Inside of the function we will use an if/else statement where the if statement will handle a successful value and the else statement handles the error. In these statements we will need to capture the values using the | | syntax as shown:

if(val) |value|{
   return value;
} else |err|{
   std.debug.panic("Panicked at Error: {any}",.{err});
}

As you can see in our if block we return the successful value we capture as the variable value, while in the else block, we capture the error as the variable err and print it using std.debug.panic.

To test out our function, I have create an error type called MathError with one field called DivideByZero. This is similar to an enum implementing the Error trait in Rust.

const MathError = error{
    DivideByZero
};

Now we can create a function called divide which checks if the denominator is zero, and if it is we return the divide by zero error.

fn divide(comptime T: type, a: T, b: T) MathError!T{
    if (b == 0){
        return MathError.DivideByZero;
    } else {
        return a / b;
    }
}

Lastly we will create our main function where we will try this with a successful result and a result doomed to panic.

If we run our program we get the following result:

$ zig build-exe unwrap.zig 
$ ./unwrap
Result: 6.71641826e-01
thread 52729 panic: Panicked at Error: error.DivideByZero
...

This article was just a fun experiment to try something I use in Rust and try it in Zig. Like in Rust, panicking isn't a good way to handle errors, and in most cases the try keyword in Zig is enough.

The Plan of an Opensource Education Platform!

Mustafif — Fri, 26 May 2023 00:10:46 +0000

A Little History

One of my first projects that I built in highschool was called MKhan Reference Library and its goal was to build a website that provides different kinds of school material for various grades. The project wasn't the best considering it had copyrighted material, and was abandoned as I further progressed past web development.

But...considering it was my first project it did show what my underlying interest was, an educational platform. I love talking about programming, I love working on it and teaching it, so why not put all of those together into my first business.

Edu-Byte!

The platform is called Edu-Byte and I don't expect it to be out of speculation until after a few years of development. My plan for this platform is to build an opensource, people focused educational website that will provide material and resources that will help someone learn any language they'd like.

Well saying any language they'd like gives me anxiety considering I'm the only person working on it at the moment, but I hope to expand with others as the idea becomes more clear.

Content Plan

In the early preview I plan on creating content on languages like Rust, Zig and C, which I am comfortable with, and I hope to get others to help me on different languages. At the moment I am writing Zig Unleashed which will be the first book written for this platform.

To explain the different content planned for this platform, it might make sense to look at a little diagram based on the code written for edubyte-metadata:

Free => Article Types/ 
           Topic 
           How to Guides 
           News 
           TrainLings 
Paid => Paid Types/ 
           Udemy courses 
           Ebooks / Book (distr. Amazon)

In terms of paid content I have planned for 5 different price tiers ($CAD) that a book could fall in, this depends on the type of content it covers and its length. (These are exclusive ranges)

Tier 1: $19.99 - $35.99
Tier 2: $35.99 - $40.99
Tier 3: $40.99 - $49.99
Tier 4: $49.99 - $69.99
Tier 5: $69.99 - $99.99

Licenses

All tools and code written for this project are planned to be under the GPLv2 license, while books will be under the CC BY-NC-ND 4.0 license. I don't have problems with pirating my books, so this license will allow you to distribute them without adaptation and for noncommercial purposes.

Comment below any features you'd like to see in this platform or any suggestions.

Using Zig in Rust!

Mustafif — Tue, 18 Apr 2023 02:41:53 +0000

In my head I thought hey how would I go about integrating Zig and Rust together in a sorta simple way, and then it came to me...they both use FFI for C interoperability. So if I would compile a Zig file as a dynamic library and link it to my Rust program treating is a C shared library, we're good to go right? I was happy to find out it does work...

Let's create a simple zig file called mylib.zig with the following add function that's exported to C.

const std = @import("std");

export fn zig_add(a: i32, b: i32) i32 {
    return a + b;
}

Let's now create a Rust file, main.rs that will have an extern block that will declare our zig_add function and in our main function we will use it, taking note that when using zig_add we will have to wrap it in an unsafe block.

extern "C" {
    fn zig_add(a: i32, b: i32) -> i32;
}

fn main() {
    let result = unsafe { zig_add(1, 2) };
    println!("1 + 2 = {}", result);
}

In our example we will be using a Linux system because of the ease with C development on it, and the fact that we will need environment variables to set our linker path. Now let's see how we can have these files work with eachother.

# compile zig file as dynamic library 
$ zig build-lib mylib.zig -dynamic 
# compile rust file linking our library 
$ rustc main.rs -L . -l mylib 
# set the linker path 
$ export LD_LIBRARY_PATH=./
$ ./main 
1 + 2 = 3

For those wondering, if we didn't set the linker path, we would get the following error:

./main: error while loading shared libraries: libmylib.so: cannot open shared object file: No such file or directory

Zig in MKProj?

Mustafif — Mon, 20 Mar 2023 21:32:21 +0000

When I first saw Rust, I honestly couldn't get my head to understand it, and I ignored it. But some time later, I found it again and started working with it, and after three years, I am still working with it and creating such complex programs with it.

I've found myself interested in system programming languages focusing on memory safety. I am actively reading the updates in the Carbon language, but one language that's also having lots of progress is Zig.

Zig sounds like one of those random variable names like foo and bar, but this isn't any arbitrary language. It's a brilliant one. It has got me so interested that I will be looking to try and have this language become the second official language in my portfolio project, MKProj. Although the start will be slow as I'll have to split my time to try and learn this while still maintaining my other priorities, I am committed to having this language be part of my portfolio project.

Why am I so interested in this language, however? First is that it can easily be placed into a C/C++ project. Secondly, it is robust,
an optimal language that can be used to build reusable, maintainable projects, and I am fascinated by how it chooses to handle edge memory cases, such as running out of memory or how values are allocated and deallocated.

One usage I see myself having this be part of is my toy language, Mufi-Lang. If my progress in this language goes well, I'll look into maintaining my version of Zig. But this is all speculation. For now, the first thing is to start learning...

If you're interested in Zig, I recommend looking at the official site for more information.

Rust For C++ Programmers

Mustafif — Mon, 06 Mar 2023 22:33:04 +0000

I would like to make an article about my recent publication Rust For C++ Programmers. This is a book I had started writing in May 2022, and after months of work I am able to show my hard work.

This book is published under BPB Online and I would like to thank the team for giving me this opportunity and the amazing support throughout the publication process.

Who's the Audience?

The audience for this book is mainly C++ programmers looking to broaden their horizons or looking for a memory safety alternative. This book uses C++ semantics better to understand Rust in the beginning/intermediate sections and teaches how to use Rust alongside C/C++ projects in the advanced chapters. An excellent addition I added in this book that isn't particularly found in other books is having a few chapters dedicated to building projects, as listed below:

Building a CLI App
- Gives experience using the structopts crate
GTK App
- Build desktop apps using the GTK framework
StdLib for Mufi
- Integrate Rust into a C project by developing a standard library for a toy language.
App in Tauri
- Learn how to develop cross-platform desktop applications using Tauri (Rust backend, Svelte frontend)

Along with the project, each chapter will contain exercises to help enforce the content each chapter goes through.

Why Rust and C++?

C and C++ are systems programming languages that dominate many different aspects of our systems, such as operating systems, desktop applications, and microservices. Still, they come with their fair share of problems.

The biggest con of using languages like C/C++ is the memory-related bugs they go through, which is the most common kind of exploitation in a program.

The advantage of using a language like Rust is that it was built from the ground up to provide memory and thread safety so that you won't see any segmentation faults, double frees, or data races.

We portrayed this book to provide C++ developers with a way to learn how to integrate Rust into a C++ project so newer features or different components can be written with higher levels of memory safety. This use case can happen in the Linux kernel, which has Rust as its second official language and is already being used for graphics drivers in the Asahi Linux project that aims to bring Linux to Apple silicon.

Where to Purchase?

The book is listed as the following:

Kindle: $9.95 USD
Paperback: $29.95 USD
Paperback + Kindle: $34.95 USD

View BPB Online

TexCreate v3 Betas!!!

Mustafif — Thu, 16 Feb 2023 00:49:35 +0000

I would like to announce that a few days ago I had published the first beta of TexCreate version 3. I had written a guide on getting started in the TexCreate Github repo and instead I will dedicate this post to cover what's been implemented and what needs to be worked on before v3.0.0 is considered stable for me.

To view the other projects that are related to TexCreate v3, take a view at the texc_v3_sources repo

What's been implemented

TexCreate repo template system
- Storing latest repos in the $HOME/.texcreate directory
Custom template support
Proper project structure creation
- An issue with version 2 was input paths that would cause compile errors

What needs to be worked on

TexCreate.com proper front end to show latest and older releases
Documentation for ...
- texcreate
- texcore
- texcreate_gen
Figuring out how to compile LaTeX asynchronously

Features to be implemented

extra feature:
- make command
  - Would add makefile option to config
- compile command
  - Would add compiler option to config
Considerations
- web command for local web interface
- generate command for interaction with texc_gen

Templates to be added from v2

Note currently v0 only contains the basic template

code
dictionary
lachaise
lachaise_modified
news
novel
theatre