DEV Community: Yaser Al-Najjar

I Built a Compiler with AI Engineering Over a Weekend. These are 3 Core Strategies for Scalable AI Development

Yaser Al-Najjar — Tue, 24 Feb 2026 18:35:30 +0000

You know that feeling when you've been doing something for years, and then someone comes along and says "nah, throw all that away"? That is exactly how I felt reading Cursor's blog post about self-driving codebases.

Don't get me wrong, I do believe this is impressive. 3M+ lines of code. Approximately 1,000 commits per hour. Thousands of agents working together to build a web browser. But something about it bugged me.

It ignores everything we have learned about software engineering.

Wait, what is wrong with 1,000 commits per hour?

As you know: Throughput is not progress.
Maybe 10 meaningful commits targeting goals we would like to achieve would be more helpful.

The Cursor approach optimizes for raw output. More agents, more commits, more lines of code. But after years of building software the "right way," here is what I know matters:

Agile development, meaning time-bounded sprints with scoped work, not infinite agent swarms.
Meaningful changes over large volume. 10 thoughtful PRs might beat 1,000 commits.
Strong feedback loops like tests, CI, and code review, rather than just hoping the agents figure it out.
Architecture decisions and interface contracts backed by documented reasoning, not emergent chaos.

So when I set out to build Sifr, a compiled programming language that uses Python syntax and compiles to Rust, I decided to do it with AI engineering. But I wanted disciplined agents. The kind that follow a process. The kind that write PRDs, create tickets, review each other's code, and do not merge without passing tests.

And let me tell you, it works. Really well. 😄

The project: a whole programming language

Before we get into the workflow, let me give you a taste of what we are building. Sifr is a compiled language with:

Python syntax plus static typing
Compilation to Rust for native binaries
A borrow-by-default ownership model
TypeScript-style union types, type narrowing, and protocols
Over 45 standard library modules with zero-panic guarantees
21 planned phases, with 11 completed and over 80 milestones

This is not a toy. It is a full compiler pipeline (lexer, parser, AST, binder, type checker, HIR, Rust codegen, rustc, and finally binary) with a roadmap stretching from language foundations all the way to a web framework, package manager, and ecosystem.

And it was built almost entirely using AI engineering following the workflow I am about to describe.

Sponsorship note:
This project was initially sponsored by CDON, a leading marketplace in the Nordics (Sweden, Norway, Denmark, Finland).

The basic workflow: implementing a feature

Let's start small. Here is how a single Task moves through the board, from an idea to merged code.

The Task moves across board columns as it progresses: Backlog -> Ready -> In Progress -> Review -> Done. Each step maps to a real action that an AI agent can execute.

Draft the Task. The agent writes a Task with the current situation, desired situation, and a suggested solution. This is scoped to a small number of changes.
Add to the board. The agent creates a GitHub issue and adds it to the project board. The Task lands in the Backlog.
Refine & prioritize. The agent assesses effort versus value and moves the highest-priority Tasks to Ready.
Work on the Task. The agent picks up the highest-priority Ready Task, creates a branch, implements the changes, runs tests locally, and creates a PR. This PR uses a template that requires an issue link, bullet-point changes, and deployment considerations. The Task moves to Review.
Review the PR. A different agent, preferably a different model, reviews the PR for logic bugs, unnecessary complexity, test coverage, style, and architecture alignment.
Adjust. The implementing agent addresses review comments.
Merge. The PR merges, and the Task moves to Done. Ship it.

What does a Task actually look like?

Let me show you a real example from Sifr. Here is Task #100: Expand Built-in Functions:

Current Situation: max(a, b) and min(a, b) with two arguments are not supported (only the list form max([1, 2]) works).
Desired Situation: All common Python built-in function signatures should work.
Suggested Solution: Update the compiler's lowering phase to handle 2-argument max/min `.
Acceptance Criteria: max(1, 2) returns 2

That is it. Small, focused, concrete. The agent implemented this in one PR.

🚨 Gotcha: You do not want to become the bottleneck. Make sure that shipping does not require you to be in the middle. That includes manual testing, manual clicking, manual deployment, all of it. If you are the human doing QA on every PR, you have defeated the purpose.

But what about bigger features?

A single Task is great for "add a len() method to strings." But what about "implement a borrow checker"? That is where Epics come in.

Here is the critical insight. Every Epic starts with a PRDS, a combined PRD and Solution Design document. The agent does not just jump in and start coding. It uses a specific tool to write a single structured document covering both sides:

Product requirements: problem statement, goals, scope, constraints, acceptance criteria (with Given/When/Then).
Solution design: architecture, data model, API design, error handling, testing strategy, trade-offs.

The PRDS gets added to the board as an Epic, refined, and then comes the part that matters most. Step 4 is a human reviewing the PRDS. This is the human-in-the-loop checkpoint. You are not reviewing 50 PRs. You are reviewing one document that shapes all of them.

Once approved, the Epic gets broken down into smaller Tasks, and those Tasks follow the basic workflow above.

And here is a step the blog posts never talk about: the Epic demo. Before marking an Epic as Done, you create a working demo that showcases all major features delivered. In Sifr, these live in a ./demos folder, each named after the Epic. If the demo does not work, the Epic is not done. Simple as that.

What does an Epic look like?

Here is Epic: Add collections.Counter. This epic was about adding the first class-based API to the standard library.

Objective: Users need to count hashable objects easily. Implement collections.Counter.
Scope:
- Define class Counter in lib/sifr/collections.sifr.
- Implement methods: __init__, most_common, total, update, keys, values.
- Add necessary rust implementation to support these methods.
Solution Design:
- Data Structure: Wrap a Rust HashMap but expose it as a Python class.
- API: Match Python's Counter API exactly.
- Testing: Verify counting works, most_common returns sorted results, and empty counters behave correctly.
Acceptance Criteria: from sifr.collections import Counter works, and Counter("hello").most_common(1) returns [('l', 2)].

The agents broke this down into tasks: implement the intrinsics, implement the Sifr class, add tests, and create a demo.

🚨 Gotcha: Without reviewing the PRDS, you cannot guarantee the results. The agent might build the completely wrong thing, beautifully. I have seen it happen.

In Sifr, every Epic has a PRDS document. The borrow-by-default Phase? It started with a PRDS that defined parameter conventions, escape analysis rules, and codegen patterns, before a single line of code was written.

Scaling the workflow: many Epics, many Phases

Okay, so you can ship a feature. You can ship a big feature. But what about building an entire programming language with 21 Phases?

This is where things get interesting.

Step 1: Plan multiple Phases top-down

The key word here is top-down. You plan the high-level Phases first, then drill into Epics within each Phase. And critically, avoid parallel Epics.

In Sifr's roadmap, each Phase has a clear ordering rationale. For example:

Type System Power comes before Standard Library, because the stdlib needs generics and closures for proper type signatures.
Error Safety comes before Stdlib Safety Remediation, because you cannot make intrinsics return Result types if the compiler does not enforce error class hierarchies yet.
Borrow-by-Default comes before Stdlib Deepening, so new stdlib functions are written with the final ownership model from day one.

Every ordering decision is documented. Not in someone's head, but in the codebase, in the roadmap, with explicit rationale for why Phase N depends on Phase N-1.

Step 2: Execute Phase by Phase

Each Epic within a Phase follows the epic workflow: PRD -> solution design -> human review -> Task breakdown -> execute. The agents pick up Tasks, implement, create PRs, get reviewed.

🚨 Gotcha: Don't execute too many Phases at once. I tried. The agents start creating workarounds for dependencies that haven't been implemented yet, and you end up with spaghetti. Sequential execution with clear Phase boundaries is the way.

Step 3: Review with a different model

This is one of my favorite tricks. After a Phase of execution, I use a different agent session (and often a different model) to review the work. The reviewer has fresh context, with no sunk cost bias or "I already wrote this so it must be right" mentality.

The reviewer runs in a feedback loop: review -> fix -> review -> fix -> review. Three iterations is the sweet spot.

Step 4: Re-planning with the judge

After review cycles, a "judge" (the smartest model you have access to) evaluates whether the plan needs to be steered. Maybe the type system completion phase revealed that the codegen architecture should be restructured first. Maybe a new constraint emerged.

The judge decides whether to continue as planned or adjust. If adjustment is needed, the plan is updated and execution continues. Multiple reviewer agents can also weigh in during this phase.

🚨 Gotcha #1: Parallel work might not be the best idea. There could be unidentified dependencies between Epics. Agents will make workarounds and create sloppy solutions instead of waiting for the right foundation to be in place.

🚨 Gotcha #2: It is good to plan for the future, but don't get stuck with too many details about later Phases. The first few Phases will teach you things that change your assumptions about later Phases (you can also update the plan and insert new phases midway). Plan the current Phase in detail, and keep future Phases as rough outlines.

What does a Phase Plan look like?

This is a snippet of how we structure high-level planning. We track all phases, and for each one, we define exactly what capabilities it unlocks:

#	Phase	Milestones	Status	What it unlocks
1	Language Foundations	6 (built-ins → codegen_quality)	completed	Single-file programs with classes, error handling, safe indexing, imports
2	Type System	6 (narrowing → ...)	completed	Generics, closures, generators, decorators, operator overloading
...	...	...	...	...
13	Type System Completion	6 (stdlib_generic_rewrite → generics_in_stdlib)	pending	Auto-init, user-facing generics, pattern matching, enums, bigint, generic stdlib

Notice the "What it unlocks" column. We don't just list technical tasks; we list capabilities. Phase 1 unlocks single-file programs. Phase 2 unlocks generics. This helps the AI (and me) understand the purpose of the phase, not just the code.

The real results

Sifr has completed 11 Phases and over 80 Epics using this workflow. The compiler handles:

A full type system with generics, protocols, union types, and type narrowing.
Over 45 stdlib modules.
Borrow-by-default ownership semantics.
Error handling with compiler-enforced exhaustiveness checking.

All of this was built with AI engineering following the structured workflow described above. Not thousands of agents racing to commit, but a disciplined process where every feature starts with a plan, gets implemented incrementally, and gets reviewed before merge.

An impressive result is that the first version of the working compiler for the core language was built over a weekend, literally on a Saturday & Sunday!!

You can find the repo here: Sifr.

Try it yourself

If you want to adopt this workflow, here is the TL;DR:

Small Tasks: Draft -> Board -> Refine -> Work -> Review -> Merge.
Epics: PRDS -> Board -> Refine -> Human Review -> Break Down into Tasks -> Execute -> Epic Demo -> Done.
Phases: Plan top-down -> Execute sequentially -> Review with different model -> Re-plan with judge.
Automate the boring stuff: Ticket creation, PR templates, review checklists, board management. Make them commands the agent can run.
Don't be the bottleneck: If shipping requires you in the loop for every PR, you have lost.

The agents are the hands and the architect is YOU.

What do you think? Have you tried applying AI engineering on a real project? I would love to hear about your workflow, so drop a comment or reach out!

Cursor vs Claude Code vs Gemini CLI

Yaser Al-Najjar — Mon, 01 Sep 2025 13:57:07 +0000

Grab a cup of coffee (or tea, no judgment ☕️) and settle in for a chat about AI agentic coding tools.

This is a personal review (no benchmarks, no automatic evals)... I promise!

Cursor

The good parts

Model Freedom - The coolest part is that you can point Cursor at any major model. Want a little GPT-5 action? Sure. Prefer Claude or Gemini? Heck yeah! Some models are better for planning (ask mode), while others shine in agent mode.
Multiple Rules Files - You can configure a folder full of different rules for, and Cursor will remember them. That's super handy, esp. when you're juggling micro-services.
Killer UX - The interface feels polished:
- You can review snippets, accept or reject them, and see diffs right inside the file.
- Need to undo? Just click the previous message + enter and poof! Instant revert, no git dance.
- Conversations are saved automatically with neat, user-friendly titles. Allowing to start right where you left off.
- Drag and drop files from the side pane into the chat area; this makes sharing code with the assistant a breeze.

But... (because there's always a “but”) 😅

Pricing Uncertainty - unexpected changes in pricing is worrying. Especially they don't own the models, Cursor can be easily affected by model vendors pricing changes.
Lazy Mode? - Sometimes the agent decides it's done (or done trying) after a handful of attempts. Not sure if this is the model or the system prompt 🤔

Claude Code: the Sorcerer with `/init`

Claude Code is a command-line wizard. It runs right in your terminal and gives you direct access to Anthropic's models.

The awesome bits

/init is magical - Run claude init and it scans your whole project, then spits out a CLAUDE.md file. This acts as a brain dump of your project's architecture, tools and conventions. See Anthropics docs: https://www.anthropic.com/engineering/claude-code-best-practices
/context command - Ever wonder why your agent context is full? This command shows what parts are passed into the context.
Top-notch docs - Anthropic's documentation is clear and thorough!
Hooks & subagents - Want to set up custom workflows? Think of it as building little AI helpers for specific tasks (I haven't tried this, but it looks promising).

The non-awesome bits

No built-in code indexing - The model decides which files to touch on its own. That can pull in huge amounts of code and spike your token usage (and bill 💸).
One big rules file - All your guidelines has to live in CLAUDE.md.
Limited VS Code integration - E.g: you either accept or reject the entire file change. No partial approvals like Cursor.
No easy revert - If Claude makes a mess, you're back to git to roll it back.

Gemini CLI

Google's Gemini CLI is a tempting alternative: very large context and much cheaper.

What's interesting

Crazy cheap - Gemini Pro 2.5 is much cheaper compared to Sonnet 4.0
Great analysis - It's very good at static reasoning tasks, e.g: comparing features vs tests or hunting down version conflicts. I've seen it figure out very subtle bugs.

What's not

Rule rebel - It tends to ignore project rules unless you keep nudging it.
Queue UX - The queued-message behavior can be clunky; it doesn't interrupt-and-resume smoothly like Claude.
Messy output - Often requires linting or manual fixes. E.g: it doesn't automatically run a TS compiler check after generation.
Manual saves - Conversations doesn't not auto-save; forget to save and you might lose the convo (maybe there is some setting that I missed)
Poor Docs - One github README is all you got 😄

Final thoughts

So, what do you think? Do you have some other AI coding secret sauce?

Deploying Apps Without Losing Your Mind

Yaser Al-Najjar — Sun, 01 Jun 2025 12:53:40 +0000

If you're anything like me, you've probably spent way too many hours figuring out the "simplest" way to deploy apps without losing your sanity. I've been bouncing around options and lemme tell you: it’s been an adventure!

Why is deploying stuff still complicated? 🤦‍♂️

You know the drill:

Deployment pipeline: CI/CD/k8s. I know, sounds easy until you get into YAML hell.
Logging and monitoring: Do you like looking at your Datadog bill?
Database setup and management: "managed" databases... still feels like babysitting at times.
Secrets and env variables
Horizontal scaling
The list goes on...

What have I tried?

Options that I have used/experimented with at different workplaces:

Hetzner/DigitalOcean/Linode: affordable, but SSH-ing into servers to deploy a simple app feels so 2010 😅
Render/Netlify/Vercel: Great UX but I think they're overcharging.
Heroku: do you even know how many Dynos you need to run your app?
AWS Elastic Beanstalk: not gonna deny, this was one of the nicest solutions as it manages an EC2 instance for you (with no additional fees). One downside top of my mind: I have to deal with lots of YAML
GCP Cloud Run/AWS Lambdas: Cold starts... 🥶
Kubernetes: Nope, nope, nope. Let's not ruin our mood today with Kubershites 💩

One common theme? All these solutions still need extra tools for production-grade stuff: secrets, DBs, logging, ugh!

Enough venting!

Recently, I stumbled across Cloudflare Workers and decided to experiment with it. Spoiler alert: it's pretty darn cool!

So, what exactly is it?

Cloudflare Workers lets you deploy apps on Cloudflare’s global network with the least amount of effort.

How does it work?

Underneath, it uses V8 engine, the same engine powering your Chrome browser.

Fun fact: the deployment region is "Earth" 🌍 and Cloudflare magically runs your worker in the closest region to your users (thanks to Cloudflare's load balancer: Unimog).

But what about those dreaded cold starts? ❄️

From the docs:

Unlike other serverless providers which use containerized processes, Workers pays the overhead of a JavaScript runtime once. Workers can start roughly a hundred times faster than Node processes in containers.

Disclaimer: I haven't ping/load/stress-tested this yet. If you have, please write in the comments!

Let's explore some of Cloudflare stack 🛠️

Compute:
- Workers: Your basic app deployments.
- Pages: Static sites hosting.
Storage:
- D1: Managed SQLite with backups and everything.
- KV: key-value store.
- Hyperdrive: Connect your DB (like Postgres) and accelerate queries.
- Queues: Simple queuing.
- R2: S3 compatible blob storage.
Extras:
- Observability: Built-in logging.
- Secrets Management: Yup, secrets are handled.
Dev tooling:
- Wrangler: development cli to simulate running workers locally.
- Hono & OpenNext: Frameworks by Cloudflare to streamline your dev experience (OpenNext is like Next.js but deployable anywhere).

To me, this sounds like most of the tools you would need to deploy your app in one place!

Have I built something or I just wanna talk about it?

Couldn't resist! I whipped up a marketplace demo app (it happens that I work at the largest marketplaces in Sweden: CDON & Fyndiq).

Yes, I did vibe-code the UI with Lovable and wrote lots of the code using Cursor 😄

You can visit the website here (unsure for how long I'll keep this available): https://marketplace-edge-shop-frontend-integration.alnyaser2.workers.dev/

Architecture

I've tried to make a micro-service architecture aiming to try out different services from Cloudflare:

This architecture follows CQRS (Command Query Responsibility Segregation) architectural pattern to keep write operations separate from read ones (merchants update products, customers browse without hiccups).

Here's my marketplace-edge repo. It's a mono-repo with the above three apps:

inventory-api: Hono api for merchants to manage products.
shop-projection: Hono api for customers to get products.
shop-frontend: OpenNext frontend/UI for customers to browse the products.

Small hiccups I found:

Shared queues: Running multiple apps locally (with shared queues) was a pain. I tackled this by creating a script to run two apps using the same wrangler instance. It would've been easier if I could run each app separately and point to the same wrangler local environment (which is a directory).
Testing: integration tests for queues were tricky. I ended up mocking instead of integration testing. I wish there was an internal tooling to make sure everything is working in an integration test.

Sounds amazing, right? But wait... 🤔

Cloudflare Workers isn’t the silver bullet for everything. Sorry to burst your bubble! Here’s when I think it's good:

Quick deployment, minimal hassle.
Cost-effective (both engineering and compute).
You're cool with system design around Cloudflare stack.

Some limitations:

Can't really build apps that run 24/7. For example: a Kafka consumer that continuously polls new messages to process (please correct me if I'm wrong in the comments). You might achieve the same result with Cloudflare Pub/Sub, but it's beta as of writing this article.
Only three languages supported:
- JavaScript/TypeScript.
- Rust.
- Python (barely usable, standard lib only).

Containers coming soon might fix that though; keep an eye out.

Your turn! 💬

What do you think?
Could Cloudflare Workers change the game for deploying your apps? Any horror stories from your own deployments? What other options would you recommend?

Let us know in the comments. I love hearing about everyone’s tech adventures!

How You can Fight Corona

Yaser Al-Najjar — Fri, 13 Mar 2020 22:27:57 +0000

I live in Istanbul (Turkey), a very crowded city that I am afraid the virus is already all around and just nobody is reporting any case.

Every single day, the amount of people using masks in public is just increasing and this just reflects the amount of increasing fear 😨

Just 2 cases have been confirmed positive here, and directly you see this happening:

source: cumhuriyet.com.tr

Mild

This is the main problem of the outbreak... yes, you heard that right: the majority of the Corona cases are mild!

You might say that the virus being mild is a good thing... not quite actually, people with mild or no symptoms are travelling around and spreading the virus to a level that it became pandemic.

The problem gets even worse when every country is hiding the actual numbers fearing that it will affect the economy 😕

Things Getting Ugly

Let's look at the numbers:

The mortality rate initial estimate by the World Health Organization (WHO) is 2%
The world population is 7.7 billion which is 7,700,000,000
Suppose that 30% of the world population gets infected that is 2,31 billion people or 2,310,000,000
Now with 2% mortality rate, it means that 46 million people or 46,200,000 are gonna be dead by this virus!

Now I think you can see why you shouldn't treat this virus as the seasonal flu, and remember that loved ones might be included within these numbers.

What Developers Can Do

Here are stuff you can do:

Engage with any contribution to find a cure using DataScience/AI.
Adopt remote working culture in your company/organization.
Encourage and help people from other industries to adopt remote working culture.

I hope there was some better data than the 2019 Wuhan Coronavirus data in this link, because that would let everyone contribute...

I am sure with the right set of data and AI techniques we would be able to answer to questions like:

What characteristics make kids less than 10 years old not being affected by this virus?
What characteristics make some people get recovered and some others dead?

Actually, what human beings need now is not a fancy dashboard to track the virus, we need a fu**** cure!

Why Opera Browser is Using Webcam?

Yaser Al-Najjar — Thu, 17 Oct 2019 09:00:51 +0000

I realized many times that Kaspersky is warning me whenever I open Opera browser that it starts using the webcam!

Opened pages

All are usual pages that do NOT require webcam functionalities, like: Asana, ZenHub, Twitter, Facebook... etc

Plugins

I checked my plugins, and it's kinda empty just those:

Install Chrome Extensions (by Opera Software).
Opera Ad Blocker (official plugin form Opera).
WordWeb Dictionary Lookup.

Why I use Opera?

Well, it's super light (memory and CPU) comparing to Google Chrome.

But I recently feel really concerned about why it uses the camera without showing any permission dialog.

I hope to see where I'm wrong at this.

In Case You Don't Know, Rust is The New "C"

Yaser Al-Najjar — Tue, 03 Sep 2019 14:58:21 +0000

Good read: “Rust is the future of systems programming, C is the new Assembly”: Intel principal engineer, Josh Triplett

I really couldn't see this before, but Rust is a replacement for C/C++, a clean replacement.

Here is Redox OS:

Redox is a Unix-like Operating System written in Rust, aiming to bring the innovations of Rust to a modern microkernel and full set of applications.

And Wasmer is pretty promising for the web world:

wasmerio / wasmer

🚀 Fast, secure, lightweight containers based on WebAssembly

Wasmer is a blazing fast and secure WebAssembly runtime that enables incredibly lightweight containers to run anywhere: from Desktop to the Cloud, Edge and your browser.

Secure by default. No file, network, or environment access, unless explicitly enabled.
Pluggable. supports WASIX, WASI out of the box.
Incredibly Fast. Run WebAssembly at near-native speeds.
Embeddable anywhere via Wasmer SDKs

Install Wasmer

curl https://get.wasmer.io -sSfL | sh

Other installation options (Powershell, Brew, Cargo, ...)

Wasmer can be installed from various package managers. Choose the one that fits best for your environment:

Powershell (Windows)
```
iwr https://win.wasmer.io -useb | iex
```

Homebrew (macOS, Linux)
```
brew install wasmer
```
Scoop (Windows)
```
scoop install wasmer
```
Chocolatey (Windows)
```
choco install wasmer
```
Cargo binstall
```
cargo binstall wasmer-cli
```
Cargo

Note: All the available features are described in the wasmer-cli crate docs
```
cargo install wasmer-cli
```

Looking for more installation options? See the wasmer-install repository to…

View on GitHub

Even it might takeover current big C/C++ implementations like this one:

RustPython / RustPython

A Python Interpreter written in Rust

RustPython

A Python-3 (CPython >= 3.14.0) Interpreter written in Rust 🐍 😱 🤘.

Usage

Check out our online demo running on WebAssembly.

RustPython requires Rust latest stable version (e.g 1.67.1 at February 7th 2023). If you don't currently have Rust installed on your system you can do so by following the instructions at rustup.rs.

To check the version of Rust you're currently running, use rustc --version. If you wish to update rustup update stable will update your Rust installation to the most recent stable release.

To build RustPython locally, first, clone the source code:

git clone https://github.com/RustPython/RustPython

RustPython uses symlinks to manage python libraries in Lib/. If on windows, running the following helps:

git config core.symlinks true

Then you can change into the RustPython directory and run the demo (Note: --release is needed to prevent stack overflow on Windows):

$ cd RustPython
$ cargo run --release demo_closures.py

…

View on GitHub

What other Rust potential use-cases do you see?

Who Else Does NOT Like Dark Mode?

Yaser Al-Najjar — Mon, 02 Sep 2019 12:56:54 +0000

In case you didn't realize, dark mode is the new trend in UI/UX.

EVERY popular app / website you use is adding the "Dark Mode" feature.

What wow-ed me recently is the ambient light sensor in browsers:

src: https://blog.arnellebalane.com/using-the-ambient-light-sensor-api-to-add-brightness-sensitive-dark-mode-to-my-website-82223e754630

Enabling Dark Mode On Websites Based On Surrounding Light

Ananya Neogi ・ Jan 4 '19

#webdev #javascript #experimental

But, I really find the dark theme annoying in so many ways.

Is it just me?

Is JavaScript Dominating the Dev World?

Yaser Al-Najjar — Sat, 17 Aug 2019 09:59:21 +0000

I read this today:

// Detect dark theme var iframe = document.getElementById('tweet-1162077731217117185-444'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1162077731217117185&theme=dark" }

I was thinking... he is very right!

And, I really find it scary.

Cuz hey, languages that you love might virtually disappear in the next 5 years in favor of JavaScript!

original cover image is from starrengroup

Will Typescript Make Your Software Bug Free?

Yaser Al-Najjar — Tue, 13 Aug 2019 17:50:56 +0000

I believe this is the WRONG QUESTION.

Previously, this topic has been discussed in different shapes here:

Article No Longer Available

And here:

No, TypeScript is not a waste of time.

Resi Respati ・ Jul 29 '19

#typescript #javascript #webdev #programming

But, these two topic forget one simple thing:

Typescript is just a matter of taste, it's not about you writing better code or them writing an ugly one.

Clean code doesn't abide to language X or Y.

After all, clean code is clean code.

What do you think?

What's your weakest backend/frontend skill?

Yaser Al-Najjar — Tue, 23 Jul 2019 12:38:46 +0000

I Got Ranked as #1 Student in Computer Engineering in My University, and Here is What I Think

Yaser Al-Najjar — Sat, 06 Jul 2019 21:36:27 +0000

// Detect dark theme var iframe = document.getElementById('tweet-1147617365405904896-812'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1147617365405904896&theme=dark" }

Was it worth it?

Hell yeah, the smile and proudness I saw on my mom and dad faces was totally worth it.

University is not just about courses and instructors, I believe it's much more than that.

Yes, you won't learn much from your university courses...
But you will meet a bunch of great people out there!

I met there in the university lots of awesome people, one of them is the co-founder of our online programming academy, Coretabs Academy.

Aside from that, living abroad in a foreign country is the best instructor you could ever get.

Living abroad teaches you tons of stuff... the top things I got from that are:

Discovering who I am.
Having a solid independent personality.

If you haven't been living abroad, do yourself a favor and GO DO IT.

If you think about the university program itself would help you, you're wrong... very very wrong.

Fun Fact

The course I've learned the most from is Accounting, which is a university elective course that comes along the Computer Engineering program.

It won't make any difference in your life

You heard that right, it's never gonna make any difference if you get better grades... cuz yeah, nobody cares.

People will applause so hard for you with the fact that they understand that university system is very broken.

I would say I owe the money that I paid for university to: Pluralsight, TeamTreehouse, and YouTube.

Those are the places where I really learned core tech skills that correspond with the actual market needs.

Fun Fact

My attendance on most courses = ZERO

I just spent the time working (remotely).
And of course, I attended the quizzes, labs, and exams to never fail a course.

I'm not saying that to brag,
I'm saying that to prove one simple thing: you can learn all university topics on your own.

What would I do next?

Here is my answer loud and clear: I DON'T KNOW!

Seriously, I don't know what path to take in the next 5 years.

But, I definitely know that I would take the most useful path in my future.

At least, I know what to do in the next couple of months.

It's gonna be making Coretabs Academy providing better services/experience for its users.

PS: If you're in Cyprus (KKTC) and you would like to hangout and chat, I would love doing so 😁

All That You Need to Know About Microsoft's New Programming Language: Bosque

Yaser Al-Najjar — Sat, 20 Apr 2019 23:38:43 +0000

What is Bosque?

From Bosque GitHub repo:

The Bosque programming language is a Microsoft Research project that is investigating language designs for writing code that is simple, obvious, and easy to reason about for both humans and machines

Lemme add a couple of points

Bosque is typed and functional.
Heavily affected by JavaScript, TypeScript, and ML.
More of a research product than a profitable product.
An open source project licensed under MIT (very non-Microsoft'ish 😁).

When was it invented?

The GitHub repo was created on 3rd of Mar, 2019, and published on Microsoft.com on 15th of April, 2019.

What's the implementation of the language?

Currently, the language is implemented on TypeScript which runs on Node.js.

So, what does it bring new into the table?

Maybe a new era of programming

The author of Bosque, Mark Marron, introduces a new programming model called Regularized Programming.

In his research paper, he mentions how structured programming (that we knew since 1970) might cause "accidental complexity"!

We believe that, just as structured programming did years ago, this regularized programming model will lead to massively improved developer productivity, increased software quality, and enable a second golden age of developments in compilers and developer tooling.

How Regularized Programming Differs from Structured Programming

You can simply say that: "Regularized Programming = Structured Programming v2.0".

That's how Marron tells us in his white paper, that regularized programming is built on structured programming... but, it aims to eliminate sources of complexity.

In other words, fewer bugs in your code!

The sources of complexity he mentions are:

Loops, Recursion, and Invariants: I assume you already know those 😆
Mutable State and Frames: mutable vs immutable objects are always confusing.
Indeterminate Behaviors, like: uninitialized variables.
Data Invariant Violations: accessing/modifying data using index in arrays and such.
Equality and Aliasing: by value, by reference variable passing.

Code sample

Instead of doing the usual iterative loop in C, e.g:

Multiply all array elements by 2.

int a[5] = {1, 2, 3, 4, 5};
int b[5];
for(int i=0; i<5; i++)
    b[i] = a[i]*2;

Bosque avoids the whole idea about looping and accessing array directly from the memory by doing:

var a = List[Int]@{1, 2, 3, 4, 5};
var b = a.map[Int](fn(x) => x*2);

It's all academic for now

Now, don't jump to use this in your company or workplace 😆

Cuz, the whole thing is academic and meant for R&D for the next programming languages generation.

Quoting from the project repo:

we do not recommend the use of the Bosque language for any production work and instead encourage experimentation only with small/experimental side projects at this point in time.

Fun fact

People are already questioning the async model for this programming language 😂

Bonus fun fact

OP: There will likely be job offers in the next few weeks asking for a couple years of experience with this new programming language.

Re: And there will be people applying with 5 years experience already too :P

What do you think

Do we really need a new programming language with a whole new paradigm?
Would it be really useful to have Bosque?

DEV Community: Yaser Al-Najjar

I Built a Compiler with AI Engineering Over a Weekend. These are 3 Core Strategies for Scalable AI Development

Wait, what is wrong with 1,000 commits per hour?

The project: a whole programming language

The basic workflow: implementing a feature

What does a Task actually look like?

But what about bigger features?

What does an Epic look like?

Scaling the workflow: many Epics, many Phases

Step 1: Plan multiple Phases top-down

Step 2: Execute Phase by Phase

Step 3: Review with a different model

Step 4: Re-planning with the judge

What does a Phase Plan look like?

The real results

Try it yourself

Cursor vs Claude Code vs Gemini CLI

Cursor

The good parts

But... (because there's always a “but”) 😅

Claude Code: the Sorcerer with /init

The awesome bits

The non-awesome bits

Gemini CLI

What's interesting

What's not

Final thoughts

Deploying Apps Without Losing Your Mind

Why is deploying stuff still complicated? 🤦‍♂️

What have I tried?

Enough venting!

So, what exactly is it?

How does it work?

But what about those dreaded cold starts? ❄️

Let's explore some of Cloudflare stack 🛠️

Have I built something or I just wanna talk about it?

Architecture

Small hiccups I found:

Sounds amazing, right? But wait... 🤔

Some limitations:

Your turn! 💬

How You can Fight Corona

Mild

Things Getting Ugly

What Developers Can Do

Why Opera Browser is Using Webcam?

Opened pages

Plugins

Why I use Opera?

In Case You Don't Know, Rust is The New "C"

wasmerio / wasmer

🚀 Fast, secure, lightweight containers based on WebAssembly

Install Wasmer

RustPython / RustPython

A Python Interpreter written in Rust

RustPython

Usage

What other Rust potential use-cases do you see?

Who Else Does NOT Like Dark Mode?

Enabling Dark Mode On Websites Based On Surrounding Light

Ananya Neogi ・ Jan 4 '19

Is JavaScript Dominating the Dev World?

Will Typescript Make Your Software Bug Free?

Article No Longer Available

No, TypeScript is not a waste of time.

Resi Respati ・ Jul 29 '19

What's your weakest backend/frontend skill?

I Got Ranked as #1 Student in Computer Engineering in My University, and Here is What I Think

Was it worth it?

Fun Fact

It won't make any difference in your life

Fun Fact

What would I do next?

All That You Need to Know About Microsoft's New Programming Language: Bosque

What is Bosque?

Lemme add a couple of points

When was it invented?

What's the implementation of the language?

So, what does it bring new into the table?

Maybe a new era of programming

Claude Code: the Sorcerer with `/init`