Forem: D

A Simple Cheat Sheet for JavaScript Developers Transitioning to Python

Wed, 30 Jul 2025 16:08:23 +0000

As a developer coming from a JavaScript background, I've found it challenging to adjust to Python's syntax and structure. The differences, especially the lack of curly braces and reliance on indentation, can be confusing.

To make my transition smoother, I created this cheat sheet comparing common JavaScript and Python syntax. It serves as a quick reference to help navigate the key differences and similarities between the two languages.

I hope this resource will make it easier for anyone else facing the same challenges in learning Python.

Concept	JavaScript	Python
Variable Declaration	`let x = 10;`	`x = 10`
Data Types	`String`, `Number`, `Boolean`, `Object`, `Array`	`str`, `int`, `float`, `bool`, `list`, `dict`
Function Definition	`function myFunc() {}`	`def my_func():`
Function Call	`myFunc();`	`my_func()`
Conditional Statements	`if (x > 10) {}`	`if x > 10:`
Loops	`for (let i = 0; i < 5; i++) {}`	`for i in range(5):`
While Loop	`while (x < 10) {}`	`while x < 10:`
Array/List	`let arr = [1, 2, 3];`	`arr = [1, 2, 3]`
Object/Dictionary	`let obj = { key: 'value' };`	`obj = {'key': 'value'}`
Accessing Elements	`arr[0]`, `obj.key`	`arr[0]`, `obj['key']`
String Concatenation	`let str = 'Hello ' + 'World';`	`str = 'Hello ' + 'World'`
Template Literals	`Hello ${name}`	`f'Hello {name}'`
Comments	`// This is a comment`	`# This is a comment`
Exception Handling	`try { } catch (e) { }`	`try: ... except Exception as e:`
Importing Modules	`import { myFunc } from './module';`	`from module import my_func`
Class Definition	`class MyClass {}`	`class MyClass:`
Class Instantiation	`let obj = new MyClass();`	`obj = MyClass()`
Arrow Functions	`const myFunc = () => {}`	`my_func = lambda: ...`
Boolean Logic	`&&`, `\|\|`, `!`	`and`, `or`, `not`

Indentation vs. Curly Braces

JavaScript:

function greet(name) {
    if (name) {
        console.log("Hello, " + name + "!");
    } else {
        console.log("Hello, World!");
    }
}
greet("Alice");

Python:

def greet(name):
    if name:
        print("Hello, " + name + "!")
    else:
        print("Hello, World!")

greet("Alice")

Whitespace Sensitivity

JavaScript:

if (true) {
    console.log("This is true.");
} else {
    console.log("This is false.");
}

Python:

if True:
    print("This is true.")
else:
    print("This is false.")

In Python, if you accidentally use inconsistent indentation, you will get an IndentationError:

if True:
    print("This is true.")
     print("This will cause an error.")  # Incorrect indentation

Data Structures

Javascript

// Array
let fruits = ["apple", "banana", "cherry"];

// Object
let person = {
    name: "Alice",
    age: 30,
    isStudent: false
};

// Set
let uniqueNumbers = new Set([1, 2, 3, 1, 2]);

Python

# List
fruits = ["apple", "banana", "cherry"]

# Dictionary
person = {
    "name": "Alice",
    "age": 30,
    "is_student": False
}

# Set
unique_numbers = {1, 2, 3, 1, 2}

Function Definitions

JavaScript

// Function Declaration
function add(a, b) {
    return a + b;
}

// Arrow Function
const multiply = (a, b) => a * b;

Python

# Function Definition
def add(a, b):
    return a + b---
---
# Lambda Function
multiply = lambda a, b: a * b

Error Handling

JavaScript

try {
    let result = riskyFunction();
} catch (error) {
    console.error("An error occurred:", error);
}

Python

try:
    result = risky_function()
except Exception as e:
    print("An error occurred:", e)

Modules and Packages

JavaScript

// Importing a module in Node.js
const fs = require('fs');

// Using ES6 module syntax
import { readFile } from 'fs';

Python

# Importing a module
import math

# Using a specific function from a module
from math import sqrt

Type System

JavaScript

// Dynamically typed
let value = 42; // number
value = "Hello"; // string

Python

# Dynamically typed
value = 42  # int
value = "Hello"  # str

If you have any suggestions or additional comparisons that could improve this cheat sheet, please feel free to share your thoughts in the comments.

Thank you for reading!

Apple's Foundation Models Framework: A Closer Look

Tue, 10 Jun 2025 02:43:39 +0000

Apple just introduced some powerful new capabilities for developers that let you bring advanced AI features directly into your apps. You might have heard terms like "AI agents" floating around, but let's break down what Apple's new Foundation Models framework means for you, simply and practically.

At its heart, this framework gives your apps access to a large language model (LLM) that runs directly on your users' devices. This is a big deal for a few reasons:

Privacy First: All the data stays on the device. Your users' information remains private, which is a huge win for trust and security.
Works Offline: No internet? No problem! Since the model is on-device, your smart features can work anywhere.
No Extra App Size: It's built into the operating system, so your app won't get bigger.

Let's look at some of the cool things this framework enables:

Getting Structured Answers (Guided Generation)

Normally, when you ask an LLM something, you get back plain text. If you want specific information (like a list of events or details about a place), it's tough to get it consistently formatted. You often end up trying to "trick" the model into giving you JSON or writing messy code to pick out what you need.

Apple's Guided Generation solves this. You can define a Swift data structure (like a struct for a Trip or an Event), and the model will guarantee it generates an instance of that structure. This means you get reliable, ready to use data every single time, making it much easier to integrate AI output into your app's design.

Smoother Streaming (Snapshots)

When an AI generates a long response, it often comes out piece by piece. Developers usually get tiny chunks of text (called "deltas") and have to stitch them together. If that text is supposed to form a complex structure, it gets even harder to show users partial results as they come in.

Instead of raw text chunks, Apple's framework streams snapshots. Imagine you're building a Trip struct. As the model thinks, it sends you partial Trip objects – maybe first the title, then the destination, then the activities start to fill in. This makes showing live, structured AI responses in your UI much smoother and simpler.

Giving Your App "Skills" (Tool Calling)

This is where things get really interesting. Tool Calling allows the AI model to use functions you've written in your app.

Think of it like this: If a user asks your travel app, "What's the weather like in Tokyo?", the LLM itself doesn't "know" the weather. But with tool calling, you can define a "weather tool" (a simple function) that can fetch this information. The LLM understands when it needs this information, "calls" your weather tool, gets the answer, and then uses that answer to give the user a complete, accurate response.

This means your app's AI can:

Access real-time data: Like weather, map data, or any other info your app has.
Perform actions: Potentially book a trip, send a message, or update a calendar entry (if you define tools for those actions).
Reduce "hallucinations": By pulling real data, the AI is less likely to make things up.

Remembering the Conversation (Stateful Sessions)

For an AI to have a natural back and forth, it needs to remember what was said before. Apple's framework uses Stateful Sessions to do this. Every interaction within a session is remembered, so the model understands context. If you ask it to "write another one" after it just wrote a haiku, it knows you mean another haiku.

This session also lets you give the AI "instructions" (like "act as a friendly travel agent") that guide its overall behavior, separate from the user's direct questions. This helps keep the AI on track and makes it safer.

Getting Started

Apple has made it easy to experiment with these features right in Xcode Playgrounds. You can quickly test prompts and see how the AI responds without having to build and run your entire app. For a comprehensive overview and to see these features in action, check out Apple's official WWDC25 session, "Meet Foundation Models" at https://developer.apple.com/videos/play/wwdc2025/286/.

This new framework opens up a world of possibilities for building more intelligent, responsive, and private apps. It's about empowering your app with smart features, all running seamlessly on your users' devices. Dive in and see what you can build!

Week 2 - of Learning AI

Sun, 08 Jun 2025 03:33:23 +0000

A quick note: I've been posting daily updates on my AI agent learning journey, but finding enough time for daily posts is tricky. So, I'm switching to a weekly format! This will be my fourth post in the series, and I'll keep documenting my progress here.

This week, I continued my dive into AI agents with some insightful resources:

How to Build an Agent by Ampcode: This article was really simple to understand and did a fantastic job of introducing agents and explaining how to use Large Language Models (LLMs). It even walked me through building a basic coding agent, which helped me truly grasp what agents are. I highly recommend it if you're just starting out.

https://ampcode.com/how-to-build-an-agent

Agents At Work 4: The Future of Coding with Thorsten Ball: This YouTube episode featured Jordi Montes and Thorsten Ball discussing AI agents in software development. Thorsten is known for his work in Go, and it was interesting to hear their thoughts on the evolving landscape of agents.

https://www.youtube.com/watch?v=J1-W9O3n7j8

My AI Skeptic Friends Are All Nuts by Fly.io: This blog post gave me mixed feelings. It definitely offered a different perspective on the AI space.

https://fly.io/blog/youre-all-nuts/

Claude Prompt Engineering Course (Google Sheet): This course, presented as a Google Sheet, is designed to help you engineer optimal prompts in Claude. It really helped improve my understanding of prompting techniques.

https://docs.google.com/spreadsheets/d/19jzLgRruG9kjUQNKtCg1ZjdD6l6weA6qRXG5zLIAhC8/edit?gid=869808629#gid=869808629

Overall, I've made some decent progress in understanding AI agents this week! I'll keep documenting this journey.

If you're also exploring AI, comment below - what resources have you found most helpful?

Let's learn together.

Day 2 of diving deep into AI Agents!

Thu, 29 May 2025 04:56:44 +0000

Just finished the Google whitepaper, and it has a very detailed and solid breakdown of AI agents.

My takeaways:

Prompt Engineering Techniques: ReAct, CoT (Chain of Thought), and ToT (Tree of Thoughts) are ways to guide the agent's reasoning.

Tool Types: Extensions, functions, and data stores – the building blocks for agents to interact with the world.

Targeted Learning: In-context learning (one-shot/few-shot - quick but can be hit or miss), retrieval-based (more complex but flexible), and fine-tuning (more effort upfront for better results).

Out of the OpenAI guide, the Anthropic blog, and this Google paper, I'd say the whitepaper gave the most detailed overview so far.

Still eager to find a cool project to build to put this knowledge into practice!

If you're also exploring AI Agents, what resources have you found most helpful?

Links:
OpenAI's guide:
https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf

Google's whitepaper on AI Agents:
https://ia800601.us.archive.org/15/items/google-ai-agents-whitepaper/Newwhitepaper_Agents.pdf

Building effective agents
https://www.anthropic.com/engineering/building-effective-agents

Thanks for being a part of my learning journey.

Day 1 of AI Agent Learning!

Tue, 27 May 2025 18:20:05 +0000

Just finished building a weather agent using OpenAI's guide. It was pretty straightforward, which is encouraging! I also spent some time reading the first part (14 pages) of Google's whitepaper on AI Agents. It's a lot of theory, but starting to sink in.

Still on the lookout for cool ideas for what to build next as I continue learning about AI Agents. Following along and excited to see where this goes!

If you're also learning about AI Agents, comment below. Let's learn together.

Any advice or resources from those who've already learned this? Please share!

I'll do my best to keep these updates coming, but life happens!

Links:
OpenAI's guide:
https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf

Google's whitepaper on AI Agents:
https://ia800601.us.archive.org/15/items/google-ai-agents-whitepaper/Newwhitepaper_Agents.pdf

My AI Agent Learning Kickoff : Day 0

Mon, 26 May 2025 01:33:08 +0000

Hello AI enthusiasts! 👋

Just starting to learn about AI Agents.My approach will be to lean heavily on openly available resources, which I'll share as I discover them.

This weekend was dedicated to absorbing knowledge from OpenAI's A Practical Guide to Building Agents and Anthropic's insightful blog post Building Effective Agents. The visual representation in Anthropic's piece was particularly helpful in grasping the end-to-end process.

One initial thought that keeps popping into my head, perhaps influenced by my background, is how the asynchronous nature of agent operations seems to align really well with Node.js's event-driven model and its built-in EventEmitter. Could this be a key runtime for agent development?

I'll investigate this further as I progress.

If you're also learning about AI Agents, comment below. Let's learn together.

Any advice or resources from those who've already learned this? Please share!

I'll do my best to keep these updates coming, but life happens!

Thanks for being a part of my learning journey.

Should you disclose your AI usage during interviews? Or keep it a secret?

Thu, 15 May 2025 00:57:35 +0000

Okay, that's a nuanced one! Gotta think strategically about this. Let's break it down.

Lean towards saying it, but frame it right.

Don't just drop, "Oh yeah, I use AI". That's lazy.

You frame it like this:

As a programmer, my goal is to deliver maximum impact and solve problems as efficiently as possible. I use AI tools not to replace my skills or thinking, but to amplify them.

For example, I use AI for boilerplate code generation, identifying potential bugs faster, or exploring different architectural patterns quickly. This allows me to free up mental energy and time to focus on the complex challenges with more creativity. It makes me faster, more thorough, and more effective.

See the difference?

You're not saying "AI does the work for me."

You're saying "I am a pragmatic programmer who understands how to use the best tools available to be significantly more productive and focus on the harder problems."

Now, yeah, there's a risk you hit an interviewer who is completely anti-AI or doesn't get it. But honestly?
As a programmer, do you really want to work at a place that doesn't understand leveraging modern tools for efficiency anyway? Think of it as a filter.

Show them you're not just good at coding; you're good at engineering SOLUTIONS efficiently in the current landscape.

So, don't keep it a secret out of fear. Be transparent, but be strategic in how you communicate the value and the leverage you gain from it.

Are AI Agents Simply LLM Wrappers?

Sun, 04 May 2025 21:29:08 +0000

Many AI Agents use Large Language Models (LLMs) for language.

But agents often do more:

Planning: They figure out how to do things step by step.
Memory: They remember what they've done.
Tool Use: They use other programs and tools.
Interaction: Some can see and act in the real world.

So, while LLMs are a key part, calling an AI Agent just an LLM wrapper misses the other important pieces that make them work.

Is Modern Web Dev Too Complex for Newcomers?

Sat, 29 Mar 2025 00:28:43 +0000

Came across a great tweet today highlighting the complexity of building web apps in 2025:

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

It made me wonder how many aspiring developers feel this way? Navigating the sheer number of tools and services can be overwhelming. For those just starting their web development journey, the initial learning curve can feel incredibly steep.

Speaking of tackling complexity, have you ever explored MeteorJS? Back in the day (and still!), it aimed to provide a more integrated, "batteries included" experience, addressing many of the challenges outlined in the tweet quite well.

Curious about how MeteorJS handled things mentioned in the tweet? Here's a checklist of how MeteorJS tackled these challenges:

💻Frontend / Backend: Offers a reactive frontend (originally Blaze, later integrated with React, Vue, and Solid) tightly coupled with a Node.js backend.

☁️ Hosting: There is a paid service, Galaxy, which allows you to deploy your Meteor app with a single command. Meteor apps can also be easily self-hosted using tools like Meteor Up.

🗄️ Database: Comes with built-in support for MongoDB and a reactive data layer that automatically pushes database changes to the frontend. Also, Meteor conveniently embeds MongoDB in its local development environment. This means you don't need to install or configure MongoDB separately to start building and experimenting with MeteorJS projects.

🔑 Authentication: Provided by official packages for handling user accounts, including password-based authentication and social logins.

📁 Blob Storage: While there are no official packages, There is a well-established packages meteor-files by Veliov Group. Which lets you pload files to AWS, GridFS, DropBox or Google Drive.

✉️Email: Supported by an official package for sending emails directly via SMTP.

⚙️Background Jobs: Meteor supports packages from the npm ecosystem. You can use your favorite npm packages for this, such as agenda.js or bull.

🔍Monitoring: If you use Galaxy hosting, monitoring is provided out of the box. If you are self-hosting, services like (Monti APM)[https://montiapm.com/] is available.

🤫Secrets (Configuration Management): It provides a built-in mechanism (Meteor.settings) for managing deployment-specific configuration, including sensitive information.

Meteor has a vibrant and helpful community! You can find an official community forum and a community-run Discord server where many developers discuss the framework and help each other out. Feel free to chime in there with your experiences or questions.

Alternatively, you can also post your questions or thoughts as a comment below this post!

If you are just starting your web development journey and feeling overwhelmed by the sheer number of choices, give MeteorJS a try! Its integrated approach can provide a smoother and more focused learning experience.

Many thanks to Harry for the detailed feedback.