Forem: akdevelop

Tools I Actually Pay For To Start Businesses

akdevelop — Sat, 26 Oct 2024 20:57:14 +0000

The tools I use in the last two years has evolved dramatically. I'm going to share the tools I use most to build and launch MVPs.

Total: $1187 / year (some one time fees included)

Development

Claude 3.5 Sonnet + Cursor

Claude is an incredible tool for brainstorming and become your decision making buddy.
Cursor for quick fast prototyping. Tip is to create a great README to help cursor find things easier.
Price: $40 per month (Combined)

SlimSaaS Dev Kit

Django + React for a scalable stack. Has a landing page as well as a SaaS frontend/backend. Makes it easy to start basically anything.
Tip: Design a page by hand and use cursor to "style like that page"
Price: $299 one-time (or $199 if on sale)

DigitalOcean

I find it way cheaper to host my servers here than anywhere else.
Tip: Use the docker droplet, makes it super easy to deploy SlimSaaS
Price: $12/mo/per project

Business

ElevenLabs

Tip: Voice changer feature is a game changer in AI voices. Makes it not sound like AI at all.
Price: $5/mo

Canva

Business proposals, Pitch decks, Social Ads, Logos, etc... Pays for itself to have templates and scrap your way through it.
Price: $120/year

Development Changed Forever

akdevelop — Tue, 15 Oct 2024 04:14:58 +0000

Every once in a while, a window of opportunity opens so wide that it practically pulls you through. That moment is now.

AI has dramatically changed the way we developers work. In the short term, it created the opportunity for us to launch incredibly fast. In the long term, well, we just don't know.

What we do know is that we need to take advantage of this "short term" super power we've been granted.

Some developers are saying that code + AI is faster than no-code.

Call to action

Consider this a call to action:

Don't resist the acceleration—harness it.
Use tools designed for this new era.
The window is wide open, but it won't stay that way forever.

The short term super power

A lot of us are still trying to figure out the landscape. Here are some tools that I use:

Code Editing: Cursor + Claude
Use Search AI (Perplexity or SearchGPT) to analyze competition and build competitive advantage.
Don't start from scratch. Use a full-stack kit, so that cursor can integrate faster. E.g. SlimSaaS
Use a UI library like Tailwind, DaisyUI, Shadcn, etc... so that AI can leverage components from those UI libraries (and not start you with an ugly screen). Starting with something like DaisyUI, will have the AI focusing on the general layout, and less on the colors. Vercel's generative UI v0
Marketing: ElevenLabs, specifically the voice changing feature is incredible for video content.

Final thoughts

A lot of the tools that I listed will probably be dead with the next wave of innovation.

Humans succeed because of the tools we create. Don't resist the tools: build faster, adapt, and launch.

Django React Login | How to setup a login page

akdevelop — Fri, 06 Sep 2024 15:11:22 +0000

Implementing a Django React login system can be challenging, but it's a crucial feature for many web applications. This guide will walk you through setting up authentication using Django on the backend and React on the front end. If you are looking for a more complete solution, check out our SlimSaaS Kit.

Setting Up Django for Authentication

Install required packages:

   pip install django djangorestframework djangorestframework-simplejwt

Create a new Django project and app:

   django-admin startproject myproject
   cd myproject
   python manage.py startapp myapp

Update settings.py:

   INSTALLED_APPS = [
       # ...
       'rest_framework',
       'rest_framework_simplejwt',
       'myapp',
   ]

   REST_FRAMEWORK = {
       'DEFAULT_AUTHENTICATION_CLASSES': (
           'rest_framework_simplejwt.authentication.JWTAuthentication',
       )
   }

Create a serializer in myapp/serializers.py:

   from rest_framework import serializers
   from django.contrib.auth.models import User

   class UserSerializer(serializers.ModelSerializer):
       class Meta:
           model = User
           fields = ('id', 'username', 'email')

Set up views in myapp/views.py:

   from rest_framework.views import APIView
   from rest_framework.response import Response
   from rest_framework import status
   from rest_framework_simplejwt.tokens import RefreshToken
   from django.contrib.auth import authenticate
   from .serializers import UserSerializer

   class LoginView(APIView):
       def post(self, request):
           username = request.data.get('username')
           password = request.data.get('password')
           user = authenticate(username=username, password=password)
           if user:
               refresh = RefreshToken.for_user(user)
               return Response({
                   'refresh': str(refresh),
                   'access': str(refresh.access_token),
                   'user': UserSerializer(user).data
               })
           return Response({'error': 'Invalid credentials'}, status=status.HTTP_401_UNAUTHORIZED)

Update myproject/urls.py:

   from django.urls import path
   from myapp.views import LoginView

   urlpatterns = [
       path('api/login/', LoginView.as_view(), name='login'),
   ]

Implementing React Frontend

Create a new React app:

   npx create-react-app frontend
   cd frontend

Install axios:

   npm install axios

Create a Login component in src/components/Login.js:

   import React, { useState } from 'react';
   import axios from 'axios';

   const Login = () => {
     const [username, setUsername] = useState('');
     const [password, setPassword] = useState('');

     const handleLogin = async (e) => {
       e.preventDefault();
       try {
         const response = await axios.post('http://localhost:8000/api/login/', {
           username,
           password
         });
         localStorage.setItem('token', response.data.access);
         // Handle successful login (e.g., redirect to dashboard)
       } catch (error) {
         console.error('Login failed:', error.response.data);
         // Handle login error (e.g., show error message)
       }
     };

     return (
       <form onSubmit={handleLogin}>
         <input
           type="text"
           value={username}
           onChange={(e) => setUsername(e.target.value)}
           placeholder="Username"
           required
         />
         <input
           type="password"
           value={password}
           onChange={(e) => setPassword(e.target.value)}
           placeholder="Password"
           required
         />
         <button type="submit">Login</button>
       </form>
     );
   };

   export default Login;

Use the Login component in your main App.js or relevant page.

Connecting Django and React

Enable CORS in Django:
- Install django-cors-headers: pip install django-cors-headers
- Add to INSTALLED_APPS in settings.py: 'corsheaders',
- Add middleware in settings.py: 'corsheaders.middleware.CorsMiddleware',
- Set CORS_ALLOW_ALL_ORIGINS = True in settings.py (for development only)
Update React API calls:
- Ensure axios is using the correct Django backend URL
- Add token to request headers for authenticated requests:
```
 axios.defaults.headers.common['Authorization'] = `Bearer ${localStorage.getItem('token')}`;
```

Testing Your Django React Login

Run Django server: python manage.py runserver
In a new terminal, run React app: npm start
Navigate to http://localhost:3000 and test the login functionality

Security Considerations

Use HTTPS in production
Implement proper CORS settings for production
Regularly update dependencies
Use environment variables for sensitive information
Implement token refresh mechanism

By following this guide, you'll have a functional Django React login system. Remember to adapt the code to your specific project requirements and always prioritize security in your implementation.

Keep in mind that this is a basic implementation and may need to be adapted to fit the specific needs of your project. If you need a more complete, production-ready solution that handles CSRF, cors, social authentication, two factor authentication, and more, check out our starter kit.

Machine Learning for Software Engineers

akdevelop — Tue, 06 Aug 2024 07:00:22 +0000

Let me know if you find this valuable and I'll keep going!

Chapter 1 - The linear model

One of the simplest yet powerful concepts is the linear model.

In ML, one of our primary goals is to make predictions based on data. The linear model is like the "Hello World" of machine learning - it's straightforward but forms the foundation for understanding more complex models.

Let's build a model to predict home prices. In this example, the output is the expected "home price", and your inputs will be things like "sqft", "num_bedrooms", etc...

def prediction(sqft, num_bedrooms, num_baths):
    weight_1, weight_2, weight_3 = .0, .0, .0  
    home_price = weight_1*sqft + weight_2*num_bedrooms + weight_3*num_baths
    return home_price

You'll notice a "weight" for each input. These weights are what create the magic behind the prediction. This example is boring as it will always output zero since the weights are zero.

So let's discover how we can find these weights.

Finding the weights

The process for finding the weights is called "training" the model.

First, we need a dataset of homes with known features (inputs) and prices (outputs). For example:

data = [
    {"sqft": 1000, "bedrooms": 2, "baths": 1, "price": 200000},
    {"sqft": 1500, "bedrooms": 3, "baths": 2, "price": 300000},
    # ... more data points ...
]

Before we create a way to update our weights, we need to know how off our predictions are. We can calculate the difference between our prediction and the actual value.

home_price = prediction(1000, 2, 1) # our weights are currently zero, so this is zero
actual_value = 200000

error = home_price - actual_value # 0 - 200000 we are way off. 
# let's square this value so we aren't dealing with negatives
error = home_price**2

Now that we have a way to know how off (error) we are for one data point, we can calculate the average error across all of the data points. This is commonly referred to as the mean squared error.

Finally, update the weights in a way that reduces the mean squared error.

We could, of course, choose random numbers and keep saving the best value as we go along- but that's inefficient. So let's explore a different method: gradient descent.

Gradient Descent

Gradient descent is an optimization algorithm used to find the best weights for our model.

The gradient is a vector that tells us how the error changes as we make small changes to each weight.

Sidebar intuition
Imagine standing on a hilly landscape, and your goal is to reach the lowest point (the minimum error). The gradient is like a compass that always points to the steepest ascent. By going against the direction of the gradient, we're taking steps towards the lowest point.

Here's how it works:

Start with random weights (or zeros).
Calculate the error for the current weights.
Calculate the gradient (slope) of the error for each weight.
Update the weights by moving a small step in the direction that reduces the error.
Repeat steps 2-4 until the error stops decreasing significantly.

How do we calculate the gradient for each error?

One way to calculate the gradient is to make small shifts in the weight, see how that impacted our error, and see where we should move from there.

def calculate_gradient(weight, data, feature_index, step_size=1e-5):
    original_error = calculate_mean_squared_error(weight, data)

    # Slightly increase the weight
    weight[feature_index] += step_size
    new_error = calculate_mean_squared_error(weight, data)

    # Calculate the slope
    gradient = (new_error - original_error) / step_size

    # Reset the weight
    weight[feature_index] -= step_size

    return gradient

Step-by-Step Breakdown

Input Parameters:
- weight: The current set of weights for our model.
- data: Our dataset of house features and prices.
- feature_index: The weight we're calculating the gradient for (0 for sqft, 1 for bedrooms, 2 for baths).
- step_size: A small value we use to slightly change the weight (default is 1e-5 or 0.00001).
Calculate Original Error:

   original_error = calculate_mean_squared_error(weight, data)

We first calculate the mean squared error with our current weights. This gives us our starting point.

Slightly Increase the Weight:

   weight[feature_index] += step_size

We increase the weight by a tiny amount (step_size). This allows us to see how a small change in the weight affects our error.

Calculate New Error:

   new_error = calculate_mean_squared_error(weight, data)

We calculate the mean squared error again with the slightly increased weight.

Calculate the Slope (Gradient):

   gradient = (new_error - original_error) / step_size

This is the key step. We're asking: "How much did the error change when we slightly increased the weight?"

If new_error > original_error, the gradient is positive, meaning increasing this weight increases the error.
If new_error < original_error, the gradient is negative, meaning increasing this weight decreases the error.
The magnitude tells us how sensitive the error is to changes in this weight.
- Reset the Weight:

   weight[feature_index] -= step_size

We put the weight back to its original value since we were testing what would happen if we changed it.

Return the Gradient:

   return gradient

We return the calculated gradient for this weight.

This is called "numerical gradient calculation" or "finite difference method". We're approximating the gradient instead of calculating it analytically.

Let's update the weights

Now that we have our gradients, we can push our weights in the opposite direction of the gradient by subtracting the gradient.

weights[i] -= gradients[i]

If our gradient is too large, we could easily overshoot our minimum by updating our weight too much. To fix this, we can multiply the gradient by some small number:

learning_rate = 0.00001
weights[i] -= learning_rate*gradients[i]

And so here is how we do it for all of the weights:

def gradient_descent(data, learning_rate=0.00001, num_iterations=1000):
    weights = [0, 0, 0]  # Start with zero weights

    for _ in range(num_iterations):
        gradients = [
            calculate_gradient(weights, data, 0), # sqft
            calculate_gradient(weights, data, 1), # bedrooms
            calculate_gradient(weights, data, 2)  # bathrooms
        ]

        # Update each weight
        for i in range(3):
            weights[i] -= learning_rate * gradients[i]

        if _ % 100 == 0:
            error = calculate_mean_squared_error(weights, data)
            print(f"Iteration {_}, Error: {error}, Weights: {weights}")

    return weights

Finally, we have our weights!

Interpreting the Model

Once we have our trained weights, we can use them to interpret our model:

The weight for 'sqft' represents the price increase per square foot.
The weight for 'bedrooms' represents the price increase per additional bedroom.
The weight for 'baths' represents the price increase per additional bathroom.

For example, if our trained weights are [100, 10000, 15000], it means:

Each square foot adds $100 to the home price.
Each bedroom adds $10,000 to the home price.
Each bathroom adds $15,000 to the home price.

Linear models, despite their simplicity, are powerful tools in machine learning. They provide a foundation for understanding more complex algorithms and offer interpretable insights into real-world problems.