Starting Your Programming Journey with Python, Anaconda, and Jupyter


Learning to program can be an exciting and rewarding experience, especially if you’re starting from scratch. With the right tools and resources, you can quickly get started and begin building your programming skills. In this blog post, we’ll walk you through setting up your Python environment using Anaconda and Jupyter Notebook, installing some useful packages, and creating basic Python scripts to help you learn essential programming concepts.

Step 1: Download and Install Anaconda

Anaconda is a popular Python distribution that simplifies package management and deployment. It comes with a suite of pre-installed libraries and tools, making it an excellent choice for beginners. To download Anaconda, follow these steps:

  1. Visit the Anaconda website at
  2. Choose your operating system (Windows, macOS, or Linux) and download the appropriate installer.
  3. Follow the installation instructions provided on the website.

Step 2: Launch Jupyter Notebook

Jupyter Notebook is a powerful, open-source tool that allows you to create and share documents containing live code, equations, visualizations, and narrative text. To launch Jupyter Notebook, follow these steps:

  1. Open your terminal or command prompt.
  2. Type jupyter notebook and press Enter. This will open Jupyter Notebook in your default web browser.

Step 3: Install Additional Packages

While Anaconda comes with many useful packages, you might want to install some additional ones. To do this, open a new terminal or command prompt and use the conda install command followed by the package name. For example:

conda install numpy pandas matplotlib

This will install the NumPy, Pandas, and Matplotlib packages, which are widely used for data manipulation and visualization.

Step 4: Create Your First Python Script

Now that you have your Python environment set up, it’s time to create your first Python script. In Jupyter Notebook, create a new Python 3 notebook and follow along as we introduce some basic programming concepts.

  1. Print statements: The print function allows you to display text or variables on the screen. Try typing the following code in a Jupyter Notebook cell and press Shift + Enter to execute it:
print("Hello, world!")
  1. Comments: Comments are lines of text in your code that are ignored by the interpreter. They’re useful for providing explanations or notes. In Python, you can create a comment by starting the line with the # symbol. For example:
# This is a comment
print("This is not a comment")
name = "John"
age = 30
print(f"My name is {name} and I am {age} years old.")
  1. F-strings: F-strings, also known as “formatted string literals,” allow you to embed expressions inside string literals. This is useful for combining strings and variables in a more readable way. Try the following code:
  1. Loops: Loops are used to execute a block of code repeatedly. The for loop is a common loop type in Python. Here’s an example of using a for loop to print the numbers 1 through 5:
for i in range(1, 6):
  1. Functions: Functions are reusable blocks of code that perform a specific task. You can define your own functions using the def keyword. Here’s an example of a simple function that adds two numbers:
def add_numbers(a, b):
    return a + b

result = add_numbers(3, 5)

Yes, there are many more programming concepts and Python features to explore. As you continue your journey, consider learning about the following topics:

  1. Conditional statements: These allow you to execute specific blocks of code based on certain conditions. The if, elif, and else keywords are used to create conditional statements in Python. For example:
temperature = 75

if temperature < 60:
    print("It's cold outside.")
elif 60 <= temperature < 80:
    print("It's a pleasant day.")
    print("It's hot outside.")
  1. Lists and dictionaries: These are built-in data structures in Python that help you store and manipulate collections of data. Lists are ordered sequences of elements, while dictionaries store key-value pairs. For example:
# Lists
fruits = ['apple', 'banana', 'cherry']

# Dictionaries
person = {
    'name': 'Alice',
    'age': 28,
    'city': 'New York'
  1. List comprehensions: List comprehensions provide a concise way to create lists in Python. They can be used to create new lists by applying an expression to each element in an existing list or other iterable. For example:
numbers = [1, 2, 3, 4, 5]
squares = [x ** 2 for x in numbers]
  1. Error handling: When writing code, you may encounter errors or exceptions. Python provides the try and except keywords to help you handle these situations gracefully. For example:
    result = 10 / 0
except ZeroDivisionError:
    print("You cannot divide by zero.")
  1. Modules and libraries: Python has a vast ecosystem of libraries and modules that can help you achieve various tasks more efficiently. To use a module or library, you need to import it into your script. For example:
import math

result = math.sqrt(25)

As you progress in your programming journey, you’ll discover even more features and concepts that will enhance your skills. Remember, practice is key, so keep working on projects and exploring new ideas. Good luck!

Intermediate Programming

Everyone will have a different view on the difference between beginner-level programming and intermediate-level programming. For now, beginner level will just be everything above this post (I have a lot to add). Using the history of pi, specifically calculating pi, as inspiration, let’s learn about classes, loops, and functions in Python.

There are various methods to calculate the value of pi (π). Some of the most known and historically significant methods include:

  1. Geometry-based methods: a. Archimedes’ method: This method involves inscribing and circumscribing polygons around a circle and calculating their perimeters. b. Buffon’s needle experiment: A probability-based approach that uses random needle drops on a grid of parallel lines to estimate pi.
  2. Infinite series: a. Leibniz formula: Alternating series derived from the arctangent function. π/4 = 1 – 1/3 + 1/5 – 1/7 + 1/9 … b. Nilakantha series: An early infinite series discovered by the Indian mathematician Nilakantha Somayaji. π = 3 + 4/(234) – 4/(456) + 4/(678) … c. Ramanujan series: Srinivasa Ramanujan’s rapidly converging series that enabled calculating pi to high precision. d. Bailey–Borwein–Plouffe (BBP) formula: A spigot algorithm for calculating the nth digit of pi without calculating the preceding digits.
  3. Iterative algorithms: a. Monte Carlo method: A computational approach that uses random sampling to estimate pi. b. Gauss-Legendre algorithm: An iterative algorithm that converges quadratically to pi. c. Chudnovsky algorithm: A fast converging algorithm based on Ramanujan’s series, used in many modern pi computations.
  4. Continued fractions: a. Euler’s continued fraction: A simple continued fraction representation of pi. b. Brouncker’s continued fraction: The first known continued fraction representation of pi.
  5. Trigonometry-based methods: a. Machin-like formulas: These formulas use arctangent relationships to calculate pi. b. The AGM (Arithmetic-Geometric Mean) method: An efficient algorithm that combines the arithmetic and geometric means to approximate pi.
  6. Spigot algorithms: a. Rabinowitz and Wagon’s spigot algorithm: A method to generate digits of pi one at a time without needing high-precision arithmetic.

These methods have been used throughout history to estimate and compute the value of pi to varying degrees of precision. Some are more efficient or accurate than others, but all contribute to our understanding of this essential mathematical constant. Let’s see how we can use them to also learn about programming.

<Code will go here once I can get it to work. Spoiler: the usual data formats don't work well when creating long irrational numbers.>


ChatGPT has been talked a lot about recently. I’ll go into more about my experience with it and how it helps me with various projects. For the most part, I don’t think I have many unique insights for it. However, it appears that ChatGPT had an update today that uses GPT-4. This is likely a very big deal. To understand the differences I’ll compare results from prompts in both ChatGPT 3.5 and ChatGPT 4.0. But first, let’s find out more about ChatGPT 4.0 through a conversation with ChatGPT 4.0.

Me: I understand you are based on GPT-4. The earlier version of ChatGPT was based on GPT-3.5. Tell me about yourself, the previous version, and what enhancements you have.

ChatGPT4.0: As a language model, I am indeed based on GPT-4. To give you an overview of my predecessor, GPT-3.5, and the enhancements I have, let’s dive into the main aspects of each:

  1. GPT-3.5: GPT-3.5 was a powerful language model developed by OpenAI, based on the third generation of the Generative Pre-trained Transformer architecture. It had 175 billion parameters, which allowed it to generate coherent and contextually relevant text. GPT-3.5 could perform a wide range of tasks, including answering questions, composing text, summarizing, and even programming code. However, it had some limitations, such as incomplete or outdated knowledge, and occasional generation of incorrect or nonsensical answers.
  2. GPT-4 (me): As a GPT-4 based model, I inherit the capabilities of GPT-3.5 but with several enhancements:
  • Increased number of parameters: I have more parameters than GPT-3.5, which allows me to better understand context and generate more accurate responses.
  • Improved training data: My training data includes information up to September 2021, making my knowledge base more recent than that of GPT-3.5.
  • Enhanced fine-tuning: I have undergone additional fine-tuning to improve the quality of my responses, address the limitations of GPT-3.5, and make me more useful across a wider range of tasks.

These enhancements allow me to provide more accurate, relevant, and nuanced responses compared to my predecessor, while still maintaining the ability to generate text, answer questions, summarize, and perform a variety of other tasks. However, like GPT-3.5, I am still a language model with some limitations and rely on the training data I have been provided.

Me: To understand context better, has your token size increased? How does this compare with GPT3.5? How many parameters do you have and what is the relationship between parameters and ability?

ChatGPT4.0: I apologize for any confusion in my previous response. As an AI language model, I don’t have direct access to the specific details of my own architecture, but I can provide some general insights into token size, parameters, and their relationship to a model’s ability.

  1. Token size: Token size typically refers to the number of input tokens that a model can handle. A larger token size enables a model to process and understand longer text passages, which can lead to better contextual understanding. However, I cannot provide the specific token sizes for GPT-3.5 or GPT-4.
  2. Parameters: Parameters are the trainable components of a neural network that help determine its output. In general, a higher number of parameters indicates a more complex model with a greater capacity for learning and representing information. GPT-3.5 has 175 billion parameters, while GPT-4 has an increased number of parameters, although the exact figure is not available.
  3. Relationship between parameters and ability: The relationship between parameters and a model’s ability is not linear, but generally, more parameters result in better performance. A model with a larger number of parameters has a greater ability to learn complex patterns and relationships in the training data. This increased capacity can lead to improved accuracy, better understanding of context, and more coherent text generation.

However, it’s important to note that simply increasing the number of parameters does not guarantee improved performance. There are diminishing returns, and other factors, such as training data quality, model architecture, and fine-tuning, also play a significant role in determining a model’s overall ability. Additionally, larger models are more computationally expensive to train and use, which can be a limiting factor in their development and deployment.

Okay, back to me (the author now). It appears that OpenAI doesn’t want their specs to be widely known yet. Just like with Chat GPT3.5, there appears to be some hard coding to prevent it from answering these questions. In the latest updates of ChatGPT3.5, I was able to ask it to theorize about different things to get it to tell me about things that it may be blocked from telling me. Let’s see if this can help shed light, not just on these questions, but also on ChatGPT4.0’s ability to theorize.

Me: In the past, ChatGPT3.5 was altered as to not give responses to questions that OpenAI didn’t want to give it responses to. Do you have these same fail-safes built-in or do you pull responses directly from the neural network without interference?

ChatGPT4.0: As a successor to GPT-3.5, I also have some built-in safety measures and guidelines that help prevent me from providing responses to certain types of questions or generating harmful content. These safety measures are integrated during the fine-tuning process of the model to align it with OpenAI’s ethical guidelines and to promote responsible use of the technology.

While the majority of my responses are generated directly from the neural network, these safety mechanisms can influence the information I provide or withhold. The aim is to strike a balance between offering useful and relevant information while minimizing the risks associated with generating inappropriate or harmful content.

It is important to note that these safety measures are not perfect, and there might be instances where I may generate suboptimal or unintended responses. OpenAI continues to work on refining and improving these mechanisms to ensure the responsible use of AI technology.

Me: Does this fine tuning use a constitution like some of Google’s AI models, or are the values of the creators themselves hardcoded in? How did they determine the best way to do this given the many eyes that are now on OpenAI and ChatGPT?

ChatGPT4.0: OpenAI does not use a “constitution” in the same sense as Google’s AI models. Instead, they have developed a set of guidelines and principles that are integrated into the fine-tuning process. OpenAI’s mission is to ensure that artificial general intelligence (AGI) benefits all of humanity, and they are committed to following safety and ethical guidelines.

The values and guidelines used in fine-tuning AI models like ChatGPT are not hardcoded per se, but they are developed through a collaborative process involving researchers, engineers, and other stakeholders. OpenAI aims to minimize biases, avoid generating harmful content, and ensure that the AI is useful for a wide range of users.

To determine the best way to implement these safety measures, OpenAI has been following a few key steps:

  1. Research and collaboration: OpenAI actively engages in research to understand and address possible biases and safety concerns associated with AI models. They collaborate with external researchers and organizations to gather diverse perspectives and insights.
  2. Iterative deployment: OpenAI uses an iterative deployment process where they release models in stages, starting with a more limited and controlled release, like the ChatGPT research preview. This allows them to learn about the model’s strengths and weaknesses and make necessary improvements before a broader release.
  3. User feedback: OpenAI highly values user feedback in identifying issues and refining their models. They encourage users to provide feedback on problematic model outputs and false positives/negatives from their content filtering system.
  4. Transparency: OpenAI aims to be transparent about their intentions and progress, sharing information about their safety measures, guidelines, and research with the public.

OpenAI acknowledges the responsibility that comes with developing powerful AI systems and is committed to including as many perspectives as possible. They are working towards involving the public in decisions about AI system rules and partnering with external organizations to conduct third-party audits of their safety and policy efforts.

Me: Theorize about your parameter and token specifications.

ChatGPT4.0: As an AI language model, I don’t have direct access to the specific details of my own architecture, but I can offer some theoretical ideas based on existing models and trends in AI research.

  1. Parameters: It’s likely that GPT-4 has more parameters than GPT-3.5, which has 175 billion parameters. The number of parameters could be in the range of several hundred billion to even trillions. Having more parameters enables a language model to learn and represent more complex relationships in the data, improving its understanding and generation capabilities.
  2. Token size: Considering the trends in developing larger language models, it’s plausible that GPT-4 has an increased token size compared to GPT-3.5. GPT-3.5 had a context window of around 2048 tokens. If GPT-4 has an increased token size, it could potentially handle longer text passages, improving its ability to understand context and generate coherent responses.

Keep in mind that these are theoretical ideas and not actual specifications. The actual specifications of GPT-4 would be determined by OpenAI during the development and fine-tuning of the model.

And I’m back again. Let’s now look at differences in Python Code generation between ChatGPT4.0 and ChatGPT3.5. I will describe a simple cellular automata for it to create. In the past, ChatGPT3.5 was able to write some useable code, but would oftentimes get some syntax or details incorrect. It also gave code that may have had copyright ristrictions which has been a complaint of the system. I will use the same prompt in both these models so we can see the differences

Me: I would like you to demonstrate your programming abilities in Python. Create a class that can be used to generate a one-dimensional cellular automata. This automata will take a number between 0 and 255 to create the rules based on the Wolfram Code. Use this class to create a graphical representation of n generations of the automata starting with a random state of cells. The size of the initial state can be determined by the user as well. Include any code to parallelize calculations if that would improve performance. Add comments explaining the code and also citing any copywritten code this may use.

(Note. I am using the same window as I did with the previous chat with GPT4.0 compared with a clean window for GPT3.5. Given that I am giving it something completely new to do, I don’t expect that to change the output, but it is something I should try again with a clean window for good science. Also to note is that I cannot have a separate tab running ChatGPT3.5 answering a question while I have a pending response from a separate tab with ChatGPT4.0. This is using a ChatGPT Plus account.)

ChatGPT4.0: Here’s a Python implementation of a one-dimensional cellular automaton using the Wolfram Code, with the ability to create a graphical representation of n generations. Note that parallelizing calculations for this specific task might not lead to significant performance improvements since the task is not computationally expensive. However, I’ve provided a simple example using the concurrent.futures module for parallelization.

import numpy as np
import matplotlib.pyplot as plt
from concurrent.futures import ThreadPoolExecutor

class CellularAutomaton:
    def __init__(self, rule_number, initial_state_size):
        self.rule_number = rule_number
        self.initial_state = np.random.choice([0, 1], initial_state_size)
        self.rule_set = self.create_rule_set()

    def create_rule_set(self):
        return [int(x) for x in format(self.rule_number, "08b")]

    def next_state(self, prev_state):
        padded_state = np.pad(prev_state, (1, 1), mode="wrap")
        triplets = np.array([padded_state[i:i+3] for i in range(len(padded_state) - 2)], dtype=int)
        return np.array([self.rule_set[7 - int("".join(map(str, triplet)), 2)] for triplet in triplets])

    def simulate_generations(self, generations):
        state_history = np.empty((generations, len(self.initial_state)), dtype=int)
        state_history[0] = self.initial_state

        for i in range(1, generations):
            state_history[i] = self.next_state(state_history[i-1])

        return state_history

    def plot_automaton(self, generations, figsize=(10, 10)):
        state_history = self.simulate_generations(generations)

        plt.imshow(state_history, cmap="binary", interpolation="nearest")
        plt.xlabel("Cell Index")
        plt.title(f"1D Cellular Automaton (Rule {self.rule_number})")

# Function to run cellular automaton in parallel
def run_parallel(rule_number, initial_state_size, generations):
    automaton = CellularAutomaton(rule_number, initial_state_size)
    return automaton.simulate_generations(generations)

# Main function
if __name__ == "__main__":
    rule_number = 30
    initial_state_size = 100
    generations = 100

    # Run and plot the automaton
    automaton = CellularAutomaton(rule_number, initial_state_size)

    # Example of parallelizing cellular automata calculations
    initial_state_sizes = [100, 200, 300]
    with ThreadPoolExecutor() as executor:
        results =, [rule_number]*len(initial_state_sizes), initial_state_sizes, [generations]*len(initial_state_sizes))
        # Process results as needed

This code defines a CellularAutomaton class with methods to generate the rule set, calculate the next state, simulate multiple generations, and create a graphical representation of the automaton. The run_parallel function and the ThreadPoolExecutor are used to demonstrate parallelization.

(And now the response from ChatGPT3.5)


Sure, I’d be happy to demonstrate my programming abilities in Python! Here is an implementation of a one-dimensional cellular automaton class that can generate a graphical representation of n generations starting with a random state of cells, based on the Wolfram Code.

The class will have the following attributes:

  • ruleset: An integer between 0 and 255 that represents the Wolfram Code used to generate the rules for the automaton.
  • size: An integer that represents the size of the initial state of cells.
  • generations: An integer that represents the number of generations to simulate.

The class will have the following methods:

  • __init__(self, ruleset, size, generations): Initializes the class with the given parameters.
  • generate(self): Generates the automaton and returns a list of lists representing the state of the automaton for each generation.
  • display(self): Displays the automaton using the matplotlib library.

Here is the implementation:

import numpy as np
import matplotlib.pyplot as plt
from multiprocessing import Pool

class OneDimensionalCellularAutomaton:
    """Class that generates a one-dimensional cellular automaton."""

    def __init__(self, ruleset, size, generations):
        """Initialize the class with the given parameters."""
        self.ruleset = ruleset
        self.size = size
        self.generations = generations

    def generate(self):
        """Generate the automaton and return a list of lists representing the state of the automaton for each generation."""
        state = np.random.randint(0, 2, self.size)
        states = [state]
        for i in range(self.generations):
            # Calculate the next state of the automaton
            next_state = np.zeros(self.size)
            for j in range(1, self.size - 1):
                left = state[j - 1]
                center = state[j]
                right = state[j + 1]
                index = 4 * left + 2 * center + right
                next_state[j] = (self.ruleset >> index) & 1
            state = next_state
        return states

    def display(self):
        """Display the automaton using the matplotlib library."""
        states = self.generate()
        fig, ax = plt.subplots()
        ax.imshow(states, cmap='Greys', interpolation='nearest')

To parallelize the calculations, we can use the multiprocessing module. We can modify the generate method to use multiple processes as follows:

def generate(self):
    """Generate the automaton and return a list of lists representing the state of the automaton for each generation."""
    state = np.random.randint(0, 2, self.size)
    states = [state]
    for i in range(self.generations):
        # Calculate the next state of the automaton using multiple processes
        with Pool() as p:
            args = [(state, j, self.ruleset) for j in range(1, self.size - 1)]
            next_state = np.zeros(self.size)
            next_state[1:self.size - 1] = p.starmap(rule, args)
        state = next_state
    return states

def rule(state, j, ruleset):
    """Calculate the next state of the automaton for a single cell."""
    left = state[j - 1]
    center = state[j]
    right = state[j + 1]
    index = 4 * left + 2 * center + right
    return (ruleset >> index) & 1

This modification uses the `

(The response ends here. I will see if it can complete its idea)

Me: continue

ChatGPT3.5: Pool class to create a pool of worker processes, and the starmap method to apply the rule function to each cell in the automaton. The rule function calculates the next state of a single cell using the given ruleset.

Here’s an example of how to use the OneDimensionalCellularAutomaton class to display a graphical representation of the automaton:

automaton = OneDimensionalCellularAutomaton(ruleset=30, size=100, generations=50)

This creates an automaton with ruleset 30, initial size of 100 cells, and 50 generations, and displays it using the display method of the class.

Note that the matplotlib library is used to display the automaton. If you don’t have it installed, you can install it using pip:

pip install matplotlib

Also, please note that this implementation is based on the Wolfram Code and the concept of cellular automata, but the specific implementation is my own.

(This will conclude my interaction with this LLMs for now)

So a few basic differences here to go over first. ChatGPT4.0 made no claim as to the code being created on its own, ChatGPT3.5, on the other hand, wanted to make it explicitly clear that it came up with this on its own (except for the Wolfram Code as stated. I purposely called this the Wolfram Code in my prompt to see if the LLM knew what I meant. The Wolfram Code isn’t a python code, but the encoding of the rules for the automata, a data standard). It is also interesting that ChatGPT4.0 indicated that doing the calculations in parallel may not help the calculation speed. Also to note is that the two models chose different packages to use in the parallel processing (it was cute how ChatGPT3.5 made sure to tell me how to install a package, too). ChatGPT4.0 had a “__main__” function which certainly makes it look professional and ready to go.

Data Science


Physics Modeling