DEV Community: Ahmad Rosid

How to create new project with Laravel Herd?

Ahmad Rosid — Sun, 15 Sep 2024 18:14:52 +0000

Did you know that Laravel, the popular PHP framework, and Herd, a new macOS-native development environment, make a powerful combination for web developers. In this tutorial, we'll walk you through setting up a Laravel project using Herd, streamlining your development workflow.

What is Herd?

Herd is a native macOS application that manages your entire PHP stack, including:

Nginx
MySQL
Multiple PHP versions

Unlike traditional setups, Herd doesn't rely on Docker or virtual machines, offering improved performance and resource efficiency.

You can download Laravel Herd here. It's the best app for those who are just getting started with Laravel.

Note: You can use laravel herd in Windows now and soon it will on linux.

Why Use Herd for Laravel Development?

Before Herd, you needed to install a lot of things to start working with a Laravel project: PHP, Composer, Node.js, and more. But with Laravel Herd, you can do all that with a single click. It significantly simplifies the setup process, allowing you to focus on development rather than configuration.

Key benefits of using Herd include:

Quick Setup: Start new Laravel projects in minutes.
Native Performance: Run your stack without virtualization overhead.
Version Flexibility: Easily switch between PHP versions.
Laravel Ecosystem Integration: Seamless compatibility with other Laravel tools.

Creating a new Laravel project

Go to your top left bar window if you on mac and top bar left if you are using windows.

Then click sites.

You will see new window being open like this.

Now click plus icon on the top of that sidebar.

Then click laravel or you can link your custom project folder.

Now choose your starter kit, I like to use Laravel Jetstream.

You can now configure the options. Each starter kit will have different configurations. Personally, I prefer these settings.

Then click next. And wait.

After it done you can now open the url or open your IDE and more.

In this example, I can open a browser with the following URL: http://blog-project.test/.

And your project is created.

If you go back to your Herd sites window, you can click the "Action" button, which provides quite useful shortcuts to manage your project.

The dust of Life

Ahmad Rosid — Thu, 05 Oct 2023 10:58:24 +0000

In our house there must be dust sticking to the floor, tables or anywhere. For most people, the dust that sticks to the walls or tables is a small problem that is sometimes often ignored and not immediately cleaned up.

It turns out that the dust that sticks everywhere can cause various diseases. I have an allergy called allergic rhinitis, this allergy can appear triggered by dust and to recover from this allergy it can take between two days to 1 week.

Three weeks ago my children Khadijah and Ibrahim were both hospitalized, they had a Respiratory Tract Infection and the doctor also said it was partly caused by dust. My wife and I could not carry out normal activities for three days because we had to take care of our children in the hospital.

However, today I don't want to discuss health topics. In recent weeks I've been thinking that this dust actually occurs in many things in our lives.

Every day there are so many small problems that we often ignore. Unexpectedly, in the long run there are more and more of them and finally they become huge problems that are very difficult to solve.

It's the same in the programmer's world. When we code there are many errors or exceptions that we don't handle, or small bugs that we ignore or poorly designed code. And in the end there are many big problems that arise from the small errors that we don't immediately fix.

Indeed sometimes one problem occurs due to another problem which may be a small problem but the impact can be great.

So what should we do?

In my opinion there are two things:
Immediately resolve those small issues now. Don't rush in doing anything, make sure you thoroughly complete it.

Let me know if you have the same experience.

Excel Gets Python Powers, But Microsoft Keeps Control

Ahmad Rosid — Thu, 24 Aug 2023 04:46:50 +0000

Introduction
Running Python Code in Excel
Benefits for Data Analysis
Reliance on Microsoft Azure Cloud
Privacy and Performance Considerations
Microsoft's AI Strategy
Conclusion

Introduction

Microsoft has announced a new collaboration with Python creator Guido van Rossum to bring Python programming capabilities to Excel. This integration aims to enhance Excel's power for data analysis tasks. However, it comes with a notable dependency on Microsoft's cloud infrastructure.

Running Python Code in Excel

The new functionality introduces a "PY" formula in Excel that allows running Python code against data in the spreadsheet. For example, users can now easily generate Pandas data frames or access plotting libraries like Matplotlib and Seaborn from within Excel. This provides the ability to create custom data wrangling and analysis functions using Python.

Benefits for Data Analysis

Access to Python's mature data science stack directly from Excel spreadsheets is an exciting development. Pandas, NumPy, and other libraries offer powerful tools for cleaning, manipulating, and analyzing data sets. Bringing these capabilities into Excel makes them more accessible to non-programmers and domain experts who rely on spreadsheets.

Reliance on Microsoft Azure Cloud

While the integration with Python is a technical achievement, Microsoft has designed it to run the Python code on their Azure cloud platform rather than natively on the user's machine. This remote execution brings some notable drawbacks compared to local Python environments.

Privacy and Performance Considerations

Requiring cloud connectivity means processed data must be transmitted external to the user's machine. This raises potential privacy concerns for sensitive data. Additionally, native local execution of Python code could offer better performance by avoiding latency and bandwidth constraints of cloud connections.

Microsoft's AI Strategy

The cloud dependency aligns with Microsoft's strategic push to be the premier platform for enterprise AI development. By controlling the Python environments, Microsoft positions Azure as the gateway for organizations to harness analytics and AI. This could give Microsoft an edge over competitors in the cloud services market.

Conclusion

Enabling Python in Excel is a major advancement that will empower Excel users to take advantage of Python's immense capabilities for data analysis. However, the reliance on Microsoft's cloud ecosystem gives the tech giant tighter control over the technology while presenting some downsides for privacy and performance compared to a local implementation. Organizations should weigh the benefits against the strategic considerations when adopting this new integration.

How to Dynamically Generate Requirements.txt file for Python Apps

Ahmad Rosid — Sun, 16 Oct 2022 03:08:49 +0000

Hey everyone, this is just a quick tutorial on how you can generate requirements.text file for your Python project. If you haven't been keeping track of all your imports and you haven't been maintaining a virtual environment.

So I started off this project. It's got quite a few imports. Some of these are built in modules, but you can see there's a couple of ones like Selenium and Rich.

And in this test file, I also have some other modules and I don't have a requirements.text file and I haven't generated a virtual environment.

So if I were to manually create a requirements.text file, I would have to manually do that. But I'm pretty lazy, so I don't want to do that. The best way that I've seen to do this is using a module called Pipreqs.

And Pipreqs, what it does is it has a look at your project. It has a look at all your imports, then it automatically generates the requirements.text for you. So I'm going to go ahead and show you how easy it is to get started with that.

First thing I'm going to do is create a virtual environment. You don't need to do this. I'm just doing it so I can show off the install of Pipreqs. So to create the virtual environment,

pip -m pip install venv

And this generates my Python virtual environment. Basically, this is just a Python environment that doesn't have any Python modules installed in it.

source VIRTUAL_ENV_NAME/bin/activate

So to activate that virtual environment, I go vm scripts and then activate.
Okay, so now let's get started with Pipreqs. And to install Pipreqs, it's just a pip install Pipreqs.

pip install pipreqs

And once you have pipreqs installed, all you need to type is pipreqs.

# generate requirements.txt
pipreqs

And it's going to automatically create your requirements.text file. So there it is right there. Click it and you can see that it automatically detected all the modules that I'm using in my project.

Now in regards to the version, I'm not actually sure how it determines which version it should be using. I think it just puts in the latest version unless you have the module already installed on your system.

Then it probably looks at the one that's installed locally and determines it that way. I'm not sure. But if you know, let us know in the comments below.

And just looking at the Pipreqs documentation, you can see it's basically everything I went over. There's a couple other options here available to you.

But I mostly just use this for quickly installing the requirements.text file. It's really easy and convenient. And I find myself using it on quite a few projects nowadays.

Create your First Command-line Application in Rust

Ahmad Rosid — Sat, 18 Jun 2022 16:17:11 +0000

Becoming a Programmer to be sure we will working with terminal a lot. Most of the time we will use command line application to do our work in terminal.

But sometime there are some workflow that we want to achieve when working on terminal but there is no application that you like to use.

So for that case you actually can write your own command line application. As for me I write a lot of command line application to automate some repeated work on terminal.

I have been trying to create command line application in various programming language, and I find that Rust is the one that make me happy. It's easy to use and the there is quite a lot library that we can use to do some operation on the terminal.

There are multiple way how we can structure our project when writing command line application, the one that I like the most is following cargo.

Project structure

When you are writing command line application, there are three boring task you need to handle.

Parsing arg input
Validate command flag
Handle the functionality

So to fix this issue let's construct our project structure like this.

└── src
    ├── cli
    │   ├── mod.rs
    │   └── parser.rs
    ├── commands
    │   ├── mod.rs
    │   └── new.rs
    └── main.rs

With this project structure we will use two crates clap and anyhow, this two library will handle argument parser and error handling.

Let's Code

First let's create a parser to our command line application, in this code we will register command and subcommand of our application.

use crate::commands;
use crate::cli::*;

pub fn parse() -> App {
    let usage = "rust-clap-cli [OPTIONS] [SUBCOMMAND]";
    App::new("rust-clap-cli")
        .allow_external_subcommands(true)
        .setting(AppSettings::DeriveDisplayOrder)
        .disable_colored_help(false)
        .override_usage(usage)
        .help_template(get_template())
        .arg(flag("version", "Print version info and exit").short('V'))
        .arg(flag("help", "List command"))
        .subcommands(commands::builtin())
}

pub fn print_help() {
    println!("{}", get_template()
        .replace("{usage}", "rust-clap-cli [OPTIONS] [SUBCOMMAND]")
        .replace("{options}", "\t--help")
    );
}

fn get_template() -> &'static str {
    "\
rust-clap-cli v0.1
USAGE:
    {usage}
OPTIONS:
{options}
Some common rust-clap-cli commands are (see all commands with --list):
    help           Show help
See 'rust-clap-cli help <command>' for more information on a specific command.\n"
}

Next: create cli module to handle some basic error handling and clap app setup.

mod parser;

pub use clap::{value_parser, AppSettings, Arg, ArgAction, ArgMatches};
pub type App = clap::Command<'static>;

pub use parser::parse;
pub use parser::print_help;

#[derive(Debug)]
pub struct Config {
}

pub fn subcommand(name: &'static str) -> App {
    App::new(name)
        .dont_collapse_args_in_usage(true)
        .setting(AppSettings::DeriveDisplayOrder)
}

pub trait AppExt: Sized {
    fn _arg(self, arg: Arg<'static>) -> Self;

    fn arg_new_opts(self) -> Self {
        self
    }
    fn arg_quiet(self) -> Self {
        self._arg(flag("quiet", "Do not print log messages").short('q'))
    }
}

impl AppExt for App {
    fn _arg(self, arg: Arg<'static>) -> Self {
        self.arg(arg)
    }
}

pub fn flag(name: &'static str, help: &'static str) -> Arg<'static> {
    Arg::new(name)
        .long(name)
        .help(help)
        .action(ArgAction::SetTrue)
}

pub fn opt(name: &'static str, help: &'static str) -> Arg<'static> {
    Arg::new(name).long(name).help(help)
}

pub type CliResult = Result<(), CliError>;

#[derive(Debug)]
pub struct CliError {
    pub error: Option<anyhow::Error>,
    pub exit_code: i32,
}

impl CliError {
    pub fn new(error: anyhow::Error, code: i32) -> CliError {
        CliError {
            error: Some(error),
            exit_code: code,
        }
    }
}

impl From<anyhow::Error> for CliError {
    fn from(err: anyhow::Error) -> CliError {
        CliError::new(err, 101)
    }
}

impl From<clap::Error> for CliError {
    fn from(err: clap::Error) -> CliError {
        let code = if err.use_stderr() { 1 } else { 0 };
        CliError::new(err.into(), code)
    }
}

impl From<std::io::Error> for CliError {
    fn from(err: std::io::Error) -> CliError {
        CliError::new(err.into(), 1)
    }
}

Sub-commands

Now let's organize our sub-command of our app, you can think of this like route to our application.

use super::cli::*;
pub mod new;

pub fn builtin() -> Vec<App> {
    vec![
        new::cli()
    ]
}

pub fn builtin_exec(cmd: &str) -> Option<fn(&mut Config, &ArgMatches) -> CliResult> {
    let f = match cmd {
        "new" => new::exec,
        _ => return None,
    };
    Some(f)
}

Thank we can easily just add new subcommand like this.

use crate::cli::*;

pub fn cli() -> App {
    subcommand("new")
        .about("Create a new rust-clap-cli  project at <path>")
        .arg_quiet()
        .arg(Arg::new("path").required(true))
        .arg(opt("registry", "Registry to use").value_name("REGISTRY"))
        .arg_new_opts()
        .after_help("Run `rust-clap-cli help new` for more detailed information.\n")
}

pub fn exec(_: &mut Config, _: &ArgMatches) -> CliResult {
    println!("Hei thanks to create new project");
    Ok(())
}

Combine All

Now let's combine all of our code and call it from main entry point of our command line application.

mod cli;
mod commands;

use cli::*;

fn main() -> CliResult {
    let mut config = Config{};
    let args = match cli::parse().try_get_matches() {
        Ok(args) => args,
        Err(e) => {
            return Err(e.into());
        }
    };

    if let Some((cmd, args)) = args.subcommand() {
        if let Some(cm) = commands::builtin_exec(cmd) {
            let _ = cm(&mut config, args);
        }
    } else {
        cli::print_help();
    }

    Ok(())
}

Now we can test our application like this.

cargo run -- new work

# Result
...
    Finished dev [unoptimized + debuginfo] target(s) in 0.03s
     Running `target/debug/rust-clap-cli new work`
Hei thanks to create new project

And if you got that message all ready to setup and you can start to create your command line app.

Full source code of this tutorial is available on github here.

Using Trait for Unit testing in Rust

Ahmad Rosid — Sun, 27 Mar 2022 06:34:03 +0000

Trait is one of powerful feature in rust. If you are coming from object oriented world, the Trait is like interface.

On of example of how we can use trait is to define abstraction for writing file. Let's create some trait code.

pub trait Buffer {
    fn write(&mut self, data: &str);
}

So these buffer we will use to be an abstraction to write file.

Next, let's create BufferWritter struct for the actual implementation to the Buffer trait.

pub struct BufferWriter {
    writer: BufWriter<File>,
}

impl BufferWriter {
    pub fn new(file: File) -> Self {
        let writer = BufWriter::new(file);
        Self { writer }
    }
}

And now let's implement our trait to BufferWritter.

impl Buffer for BufferWriter {
    fn write(&mut self, data: &str) {
        let bytes = format!("{}\n", data).as_bytes();
        if let Err(e) = self.writer.write_all(bytes) {
            println!("Failed to write data to file: {}", e);
        }
    }
}

And now let's use it to write file, first let's suppose we have some logic that made some text processing and turn it to some generated code.

pub fn write_output(buffer: Box<dyn Buffer>, config: &Config, source: &HashSet<String>) {
    let mut generator = Parser::new(buffer, config.clone());
    for line in source.iter() {
        if generator.plugin(line).is_some() {
            continue;
        }
    }
}

And here's our parser.

pub struct Parser {
    config: Config,
    writer: Box<dyn Buffer>,
}

impl Parser {
    pub fn new(writer: Box<dyn Buffer>, config: Config) -> Self {
        Self { config, writer }
    }
    pub fn plugin(&self, line: &str) {
        // Some processing and then
        self.writter.write(some_str);
    }
}

Testing

One of the advantage of trait is for testing. In this case, we don't want to work with file directly whenever we are doing testing.

So let's take a look how we can use trait for testing.

#[test]
fn test_columns() {
    let config_set = Parser::parse(include_str!("source.json")).unwrap();
    let test_case = vec![
        ("name", "my-name"),
        ("wrong", "not-wrong"),
    ];

    struct Buf(String);
    impl Buffer for Buf {
        fn write(&mut self, data: &str) {
            assert_eq!(data, self.0)
        }
    }

    for (class, expected) in test_case {
        write_output(Box::new(Buf(expected.into())), &config_set, &set![class]);
    }
}

So that it for now, if you want to read more about rust tutorial follow me at twitter @_ahmadrosid and don't forget to visit my blog ahmadrosid.com

Thank you let me know if you have any question.