Moojo

moojo

As a programmer, I'm always on the lookout for new languages that shake things up. Recently, a name language kept popping up in AI circles - Mojo. This brand-new, proprietary language from Modular Inc. promises to be a game-changer, particularly for AI developers. It aims to combine the robustness of statically typed languages like C# or Java with the flexibility and developer-friendliness of dynamic languages like Python or JavaScript. But is it all hype, or does it truly live up to its claims? Buckle up, because in this blog, I'm going to share some amazing things about Mojo. What is Mojo? Mojo is a new proprietary programming language that is currently under development. It is available both in browsers via Jupyter notebooks, and locally on both Linux and macOS. Mojo combines the usability of Python with its syntax (and aims to become a superset of it) with the high performance of languages like C. Since the launch of the Mojo programming language on May 2nd, more than 120K+ developers have signed up to use the Mojo Playground and 19K+ developers actively discuss Mojo on Discord and GitHub. Today, Mojo is now available for local download – beginning with Linux systems and adding Mac and Windows in coming releases. While the Mojo Playground provides an easy hosted introduction to the language, the local Mojo toolchain empowers developers to accomplish much more. Local developer tools provide access to the full power of Mojo, including a full set of compiler features and IDE tools that make it easy to build and iterate on Mojo applications. Key Features of Mojo Mojo is a new programming language for AI developers that will grow into a superset of Python over time. It already supports integrating with arbitrary Python code seamlessly and has a scalable programming model to target performance-critical systems, including accelerators (e.g. GPUs) that are pervasive in AI. Mojo enables me to progressively adopt new features to enable high performance where I need it. It combines the best of dynamic and static languages and can achieve up to 68,000x the performance of Python today. I can read more about Mojo's origin story in the docs, but let me recap a few important benefits that Mojo unlocks for me: Write Everything in One Language Mojo meets AI developers like myself where we are, combining the usability of Python with the systems programming features that cause developers to have to reach for C, C++, or CUDA. Unlock Python Performance Python is pervasive, but not the right tool for tasks that require high performance or exotic hardware. Mojo enables high performance on CPUs, as well as support for exotic accelerators like GPUs and ASICs, providing performance on par with C++ and CUDA. Access the Entire Python Ecosystem Mojo provides full interoperability with the Python ecosystem, making it seamless for me to use the Python libraries while taking advantage of Mojo's features and performance benefits. For example, you can seamlessly intermix NumPy and Matplotlib with your Mojo code. Is Mojo the Next Big Thing? While it's still early days for Mojo, the language holds immense promise for the future of AI development. Its focus on developer experience, combined with its raw performance and built-in AI functionalities, makes it an attractive option for both beginners and seasoned professionals. Of course, there are some things to consider. Being proprietary, Mojo might not enjoy the same level of community support as open-source languages. Additionally, as a new language, its ecosystem of libraries and frameworks might be limited compared to established players. However, the team behind Mojo seems dedicated to continuous improvement. With its active development and focus on collaboration, I believe Mojo has the potential to carve a niche for itself in the ever-evolving AI landscape. Final Thoughts: Stay Tuned for the Mojo Revolution! Overall, Mojo is an exciting new development in the world of AI programming. Whether it becomes the dominant language remains to be seen, but it definitely offers a compelling alternative for developers seeking a balance between ease of use and unparalleled performance. As an AI enthusiast, I'm waiting and eager to see how this language empowers developers to create the next generation of groundbreaking AI applications. So, what are you waiting for? Head over to the official Mojo website and explore this fiery new language for yourself. Who knows, you might just be at the forefront of the next AI revolution! As a programmer, I'm always on the lookout for new languages that shake things up. Recently, a name language kept popping up in AI circles - Mojo. This brand-new, proprietary language from Modular Inc. promises to be a game-changer, particularly for AI developers. It aims to combine the robustness of statically typed languages like C# or Java with the flexibility and developer-friendliness of dynamic languages like Python or JavaScript. But is it all hype, or does it truly live up to its claims? Buckle up, because in this blog, I'm going to share some amazing things about Mojo. What is Mojo? What is Mojo? Mojo is a new proprietary programming language that is currently under development. It is available both in browsers via Jupyter notebooks , and locally on both Linux and macOS. Mojo combines the usability of Python with its syntax (and aims to become a superset of it) with the high performance of languages like C. Jupyter notebooks Since the launch of the Mojo programming language on May 2nd, more than 120K+ developers have signed up to use the Mojo Playground and 19K+ developers actively discuss Mojo on Discord and GitHub. Today, Mojo is now available for local download – beginning with Linux systems and adding Mac and Windows in coming releases. While the Mojo Playground provides an easy hosted introduction to the language, the local Mojo toolchain empowers developers to accomplish much more. Local developer tools provide access to the full power of Mojo, including a full set of compiler features and IDE tools that make it easy to build and iterate on Mojo applications. Key Features of Mojo Mojo is a new programming language for AI developers that will grow into a superset of Python over time. It already supports integrating with arbitrary Python code seamlessly and has a scalable programming model to target performance-critical systems, including accelerators (e.g. GPUs) that are pervasive in AI. Mojo enables me to progressively adopt new features to enable high performance where I need it. It combines the best of dynamic and static languages and can achieve up to 68,000x the performance of Python today. I can read more about Mojo's origin story in the docs, but let me recap a few important benefits that Mojo unlocks for me: Write Everything in One Language Mojo meets AI developers like myself where we are, combining the usability of Python with the systems programming features that cause developers to have to reach for C, C++, or CUDA. Unlock Python Performance Python is pervasive, but not the right tool for tasks that require high performance or exotic hardware. Mojo enables high performance on CPUs, as well as support for exotic accelerators like GPUs and ASICs, providing performance on par with C++ and CUDA. Access the Entire Python Ecosystem Mojo provides full interoperability with the Python ecosystem, making it seamless for me to use the Python libraries while taking advantage of Mojo's features and performance benefits. For example, you can seamlessly intermix NumPy and Matplotlib with your Mojo code. NumPy Matplotlib Is Mojo the Next Big Thing? While it's still early days for Mojo, the language holds immense promise for the future of AI development. Its focus on developer experience, combined with its raw performance and built-in AI functionalities, makes it an attractive option for both beginners and seasoned professionals. Of course, there are some things to consider. Being proprietary, Mojo might not enjoy the same level of community support as open-source languages. Additionally, as a new language, its ecosystem of libraries and frameworks might be limited compared to established players. However, the team behind Mojo seems dedicated to continuous improvement. With its active development and focus on collaboration, I believe Mojo has the potential to carve a niche for itself in the ever-evolving AI landscape. Final Thoughts: Stay Tuned for the Mojo Revolution! Overall, Mojo is an exciting new development in the world of AI programming. Whether it becomes the dominant language remains to be seen, but it definitely offers a compelling alternative for developers seeking a balance between ease of use and unparalleled performance. As an AI enthusiast, I'm waiting and eager to see how this language empowers developers to create the next generation of groundbreaking AI applications. So, what are you waiting for? Head over to the official Mojo website and explore this fiery new language for yourself. Who knows, you might just be at the forefront of the next AI revolution!

Mojo: The New Generation Programming Language

Mojo is a language that combines the readability of Python with the speed of C++. It's useful for different things, from low-level code that's close to hardware, via the Back-End API design, to the world of Front-End and the Web. Mojo is powerful enough to scale across the entire modern stack. The language has also been designed with AI and Machine Learning in mind — so it will be particularly useful for AI developers and Data Scientists. Mojo is still young though. The ecosystem has been missing the tools for everyday software development, like networking or basic HTTP operations. This is where flies in. Lightbug 🔥🐝 is a simple HTTP framework written in pure Mojo, with no external dependencies by default. It's meant to serve as a foundation for more complex projects and allows you to develop Web services like APIs, set up basic routing, or even serve HTML pages with Mojo, while taking advantage of the features of this language, like static typing and great performance. Lightbug 🔥🐝 To get started, simply and , then clone the Lightbug Github repo: install Mojo Git git clone https://github.com/saviorand/lightbug_http.git Once it's cloned, switch to the directory in your command line: cd lightbug_http Then run the server (yes, that's the Mojo file extension! 🔥): mojo lightbug.🔥 You should see the following line printed to the console: 🔥🐝 Lightbug is listening on 0.0.0.0:8080
Ready to accept connections... Now, you can start making requests to your server or try opening or in the browser — you should see the intro screen. Welcome to the Web, Mojo-style! Now, let's get to some real coding. localhost:8080 0.0.0.0:8080 While Lightbug is still young, the core functionality people expect to be able to develop for the modern Web is already there. Note that since there's no package manager yet, you should simply include as a subfolder inside your own project. This will work as a and will allow you to import tools like web primitives, servers, and more from Lightbug. lightbug_http Mojo package For example, add this to the top of your file to import the server: from lightbug_http.sys.server import SysServer This will import a server implementation in pure Mojo. If you want to use the Python implementation, import the instead. It will work in the same manner. PythonServer To make an HTTP service, simply make a struct that satisfies the , meaning it has a method with the following signature: HTTPService trait func trait HTTPService:
 fn func(self, req: HTTPRequest) raises -> HTTPResponse:
     ... This uses the built-in primitives to take in an , execute any custom logic you write in Mojo or Python, and return an object with some data back to the API consumer. HTTPRequest HTTPResponse Let's make a service that prints all requests sent to to the console. To do this, create a file called , and paste the following: 0.0.0.0:8080 my_awesome_service.🔥 from lightbug_http import *

@value
struct Printer(HTTPService):
   fn func(self, req: HTTPRequest) raises -> HTTPResponse:
      let body = req.body_raw
      print(String(body))
      return OK(body)

fn main() raises:
    var server = SysServer()
    let handler = Printer()
    server.listen_and_serve("0.0.0.0:8080", handler) Run , and send the request to from your favorite API clients, like or . You should see some details about the request printed to the console. mojo my_awesome_service.🔥 0.0.0.0:8080 Insomnia Bruno Congrats! You're officially a Mojo web developer now 🔥. In the example, we initialize a variable called with (meaning it cannot be re-assigned) and pass it to as a second parameter for clarity. handler let listen_and_serve Adding a decorator is optional: if you're an advanced Mojician, you can add an instead. It will work the same; just generates this and other useful methods automatically. @value __init__ constructor method @value struct Printer(HTTPService):
	fn __init__(inout self):
		print("Printer initialized!")

	fn func(self, req: HTTPRequest) raises -> HTTPResponse:
		let body = req.body_raw	
		print(String(body))
		return OK(body) You might say, but that's just one route! Modern APIs require much more than that. Lightbug can also do some basic routing as well: @value
struct ExampleRouter(HTTPService):
   fn func(self, req: HTTPRequest) raises -> HTTPResponse:
      let body = req.body_raw
      let uri = req.uri()

      if uri.path() == "/":
            print("I'm on the index path!")
      if uri.path() == "/first":
            print("I'm on /first!")
      elif uri.path() == "/second":
            print("I'm on /second!")

      return OK(body) Add this to your , and pass it as a handler to the server: my_awesome_service.🔥 fn main() raises:
    var server = SysServer()
	let handler = ExampleRouter()
	server.listen_and_serve("0.0.0.0:8080", handler) You can now open your browser and go to , to see the changes. localhost:8080/first localhost:8080/second This functionality should give you a basis to develop your own apps, libraries, and services that make use of HTTP, while taking advantage of the flexibility and customization options that a lightweight framework/toolkit that is the can provide. lightbug_http We plan on making routing, as well as other tasks like authoring and generating APIs from an OpenAPI specification, designing your data model, and building web applications even more enjoyable in the future by building and packages. Check out our for details. lightbug_api lightbug_web Roadmap That's it for an introduction to ! Hope it was useful. Lightbug 🔥🐝 This is an open-source, non-commercial community project. Please star ⭐ our , join the , and check out how to contribute with your code, so we can make it even better for the fellow Mojicians. Github repo Discord Til’ next time!

Lightbug 🔥🐝- The First Mojo HTTP Framework

লাইটবাগ 🔥🐝- প্রথম মোজো HTTP ফ্রেমওয়ার্ক

Lightbug 🔥🐝 – Das erste Mojo HTTP Framework

Lightbug 🔥🐝- El primer marco HTTP de Mojo

Lightbug 🔥🐝 - Le premier framework HTTP Mojo

लाइटबग 🔥🐝- पहला मोजो HTTP फ्रेमवर्क

Lightbug 🔥🐝 - 最初の Mojo HTTP フレームワーク

Lightbug 🔥🐝- 최초의 Mojo HTTP 프레임워크

Lightbug 🔥🐝- O primeiro framework Mojo HTTP

Lightbug 🔥🐝 — первый HTTP-фреймворк Mojo

Lightbug 🔥🐝- İlk Mojo HTTP Çerçevesi

Lightbug 🔥🐝- Khung HTTP Mojo đầu tiên

Lightbug 🔥🐝 - 第一个 Mojo HTTP 框架

What is Mojo language? Mojo is a new language for AI development. The language is being developed by the Modular company. The developer says, that it combines the best of Python syntax with systems programming and metaprogramming and lets you write portable code that's faster than C and interoperates seamlessly with the Python ecosystem. programming According to the official website, Mojo supports parallel threading and is 68,000 times faster than Python. Why this project is important? Mojo is becoming more and more popular and the community is growing actively. So, I decided to try to write my first data science project, but in Mojo language. I am excited to try a new programming language and start learning it before its popularity explodes. This article is being written in December 2023, so this code is valid for that period. So, I strongly believe this little guide will be valuable for someone interested in Mojo. Code from the article is available in this GitHub repo https://github.com/OberemokAlexandra/mojo_experiments/tree/main How to install Mojo language and start experiments? There are two ways to get started with Mojo. The first is to install it manually on your laptop. Instructions for each operating system can be found here https://developer.modular.com/download Installation takes time - be prepared But there is an easier and faster way to try out Mojo on your own: the free JupiterLab playground is available here: https://playground.modular.com/ I set up all the components on my laptop, and all the code below was tested on the environment, which was configured by me on my laptop. Choose of the dataset As it is my very first data project on Mojo - a regression task, I decided to choose a dataset from the sklearn library - diabetes dataset - https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_diabetes.html Iris and Titanic datasets are the basis for classification tasks, so not today 🙂 . This dataset contains measurements from 442 diabetic patients. There are 10 features with different magical measurements, and the target is a quantitative measure of disease progression over a year. A great explanation of the features is given here https://rowannicholls.github.io/python/data/sklearn_datasets/diabetes.html Installation of Python modules with Mojo Mojo has built-in support for Python infrastructure - so it's quite easy to import a required module. For example, a numpy import will look like this. # first line imports a Python module in Mojo
from python import Python
# This line imports a numpy module itself
let np = Python.import_module("numpy") Don’t forget to install the necessary  modules in your environment first. For example, pip install numpy Get the dataset Variables in Mojo can be declared with two keywords - let and var. The main difference between them is that “let” is used to declare an immutable variable, while “var” is needed to state a mutable variable. In a Mojo, there are two ways to declare a function - by using def and fn keywords. More detailed information about the difference between the keywords can be found here: https://docs.modular.com/mojo/manual/functions.html Here is a function to return a dataset for further modeling. fn get_data() raises -> PythonObject:
    # Import of sklearn module with ready datasets
    # It’s possible to import a whole module
    let datasets = Python.import_module("sklearn.datasets")  
    let ds = datasets.load_diabetes()
    return ds Function to split, build an ml model, and evaluate its performance fn main() raises:
    # gets data from previous function
    let ds = get_data()
    let X = ds['data']
    let y = ds['target']
    # import needed sklearn module for train_test split
    let model_selection = Python.import_module("sklearn.model_selection")
    let split = model_selection.train_test_split(X, y)
    # Unpacking looks much harder than in python
    let X_train = split[0]
    let X_test = split[1]
    let y_train = split[2]
    let y_test = split[3]
    # modeling process
    let linear_model = Python.import_module("sklearn.linear_model")
    var regr = linear_model.LinearRegression()
    regr.fit(X_train, y_train)
    let pred = regr.predict(X_test) Metrics and results Let’s evaluate the regression model and see the results let metrics = Python.import_module("sklearn.metrics")
print("mean")
print(np.mean(y_test))
print("mse")
print(metrics.mean_squared_error(y_test, pred))
print("mae")
print(metrics.mean_absolute_error(y_test, pred))
print("r2")
print(metrics.r2_score(y_test, pred)) The results look like this Warning: your results may differ from those given here due to the random splitting of the data into training and test samples and model evaluation procedure Brief metrics analysis and explanation: Mean shows the mean value in the test split A huge value of the mse metric compared to a relatively small mae value may indicate that there are outliers in the test sample. The R-squared metric represents how much of the variance from the mean is accounted for by the model. In our case, it equals approximately 0.6, and it means that the model deserves to be considered. Mojo vs Python I’ve rewritten the same code in Python. To make the experiment clear and honest, I maintained the same settings on Python (trust me, you can make much more using Python). Here is the code listed below from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import numpy as np

def get_data():
    """returns dataset for modeling"""
    return load_diabetes()


def main():
    """performs all the modeling actions"""
    ds = get_data()
    X, y = ds['data'], ds['target']
    X_train, X_test, y_train, y_test = train_test_split(X, y)
    regr = LinearRegression()
    regr.fit(X_train, y_train)
    pred = regr.predict(X_test)
    print("mean")
    print(np.mean(y_test))
    print("mse")
    print(mean_squared_error(y_test, pred))
    print("mae")
    print(mean_absolute_error(y_test, pred))
    print("r2")
    print(r2_score(y_test, pred)) It is seen that modeling results using Python are comparable. Challenges The challenges below are valid for December 2023. By the time you are reading this article, they may have already been fixed For now, the hardest part - is that it’s almost impossible to pass arguments easily to a Python module in Mojo data = load_diabetes(as_frame=True) Nowadays, I can’t pass parameters like as_frame=True in Mojo code. It can lead to difficulties when using and tuning complex models Based on information from Github, this feature is on request to develop issue link - https://github.com/modularml/mojo/issues/702 I couldn't unpack values in “the Python way.” I can't write a line of code like this X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42) I only could do something like this let split = model_selection.train_test_split(X, y)
let X_train = split[0]
let X_test = split[1]
let y_train = split[2]
let y_test = split[3] Conclusion Mojo is a new programming language under development. Today, it is possible to write code with a simple regression model. Some features need to be introduced for more development abilities, but I strongly believe that the new programming language has potential and will gain more popularity in the future.

A New Programming Language For AI: Linear Regression, But With Mojo Language

The Noonification: Mojo Traits: How Do They Compare to Go Interfaces? (12/26/2023)

Traits were introduced in Mojo recently, so I thought I'd try them out. Currently, the built-in traits include , , , , , , and (looks like the "-able" suffix is a thing in these naming conventions!). Traits work on structs. To implement a trait, you simply add a method to a struct that matches the trait; then pass the trait name as a parameter: CollectionElement Copyable Destructable Intable Movable Sized Stringable @value  
struct Duck(Quackable):      
  fn quack(self):          
     print("Quack!") The decorator in Mojo inserts the lifecycle methods like , and into the struct, simplifying our life a bit as we don’t have to add them ourselves. @value __init__() __copyinit__() __moveinit__() Traits in Mojo don't support default implementations for methods yet, hence, the in the body of the method above. You can also use , which will have the same effect, as in Python. ... Quackable pass Mojo Traits vs. Go Interfaces Despite the different name, the basic approach to traits in Mojo reminds me of Go interfaces. In Go, you would define a struct and implement a interface like this: Duck Quackable type Quackable interface {
	quack()
} And to make a struct that satisfies this interface: type Duck struct {}

func (d Duck) quack() {
    fmt.Println("Quack!")
} Compare it to a Mojo implementation: trait Quackable:  
    fn quack(self):  
        ...

@value  
struct Duck(Quackable):  
    fn quack(self):  
        print("Quack!") I think the Mojo version is even more concise, nesting the method definition inside the struct type. In addition to working on structs, traits in Mojo don't require an keyword, just like in Go. quack() Duck implements Interestingly, the point is made in Mojo docs that default implementations are not allowed , meaning they might be allowed in the future. This means that Mojo might pursue an approach different from Go, which focuses on structs an interface, not it. yet satisfying implementing Default method implementations are not needed in Go, and a similar effect is achieved with embedding, as interface/trait implementation is simply a concept that doesn't exist in Go. Things might be different in Mojo. How to Use Mojo Traits The value of traits and interfaces is to make code reusable. For instance, in Mojo, you can write functions that accept trait types… fn make_it_quack[T: Quackable](could_be_duck: T): 
    could_be_duck.quack() And then pass different structs that implement the same trait as input - everything will just work! For example, here's a struct that implements : Goose Quackable @value  
struct Goose(Quackable):  
    fn quack(self):  
        print("Honk!") And here, to call on both the and the (remember, you need the function in Mojo as an entry point to your program): make_it_quack Goose Duck main def main():  
    make_it_quack(Duck())  
    make_it_quack(Goose()) The output of this will be Quack!
Honk! Trait Errors If I tried to pass in something that doesn't implement the trait to the function, let's say , the program won't compile: Quackable make_it_quack StealthCow @value
struct StealthCow():
    pass make_it_quack(StealthCow()) The error message below could have been more descriptive; maybe the Mojo team will improve it? error: invalid call to 'make_it_quack': callee expects 1 input parameter, 
but 0 were specified Same if I remove the method from ; here, we get a nice, descriptive error: quack Goose struct 'Goose' does not implement all requirements for 'Quackable'
required function 'quack' is not implemented The advantage of this kind of static type checking over the pure Python approach is that we can catch errors easily and avoid shipping any mistakes to production as the code will simply not compile. Inheritance Traits in Mojo already support inheritance, so our `Quackable` trait can extend an `Audible` trait like so: trait Audible:
    fn make_sound(self):
        ... trait Quackable(Audible):  
    fn quack(self):  
        ... This means that a struct will have to implement both and to conform to the trait. Duck quack make_sound Quackable This is similar to the concept of "Interface embedding" in Go, where to make a new interface that inherits from other interfaces, you would embed parent interfaces like this: type Quackable interface {
	Audible  // includes methods of Audible in Quackable's method set
} Static Methods Traits also accept static methods that work without creating an instance of a struct: trait Swims:  
    @staticmethod  
    fn swim():  
        ...

@value  
struct Duck(Quackable, Swims):  
    fn quack(self):  
        print("Quack!")  

    @staticmethod  
    fn swim():  
        print("Swimming") fn make_it_swim[T: Swims]():  
    T.swim() You call a static method like this: def main():
	make_it_quack(Duck())
	make_it_quack(Goose())
	Duck.swim() Which will output: Quack!
Honk!
Swimming Notice that in the last method call, a Duck instance is not created. This is how static methods in Python work, departing somewhat from object-oriented programming. Mojo builds on this Python functionality. Limitations of Mojo Traits Compared to Go Interfaces Interestingly, the Go trick with an empty that allows to pass any type and was popular with the Go community before Go Generics were introduced, will not work with a Mojo-typed function . interface{} fn Your struct has to implement at least one of the lifecycle methods like, or , which in this case, would make it conform to or , to be used with functions that accept trait types. __len__ __str__ Sized Stringable This is actually not a real limitation and makes a lot of sense in Mojo, since, with Mojo, if you need dynamic typing, you can just fall back onto the more flexible function, and then apply the usual Python magic to work with unknown types. def The more strict Mojo functions also work on generic structs using types like ; read more about that . fn DynamicVector here Another limitation I see has to do with structs and their methods rather than with traits and is a potential obstacle to implementing Clean Architecture/separating code into different parts. Consider one of the previous examples with a Go vs. Mojo struct method definition: type Duck struct {}

func (d Duck) quack() {
    fmt.Println("Quack!")
} @value  
struct Duck(Quackable):  
    fn quack(self):  
        print("Quack!") The Mojo example, following a more Python-like syntax, nests the method definition directly inside the struct, while the Go version allows it to separate it from the struct itself. In this version, if I have a very long struct with many types and methods, it will be somewhat harder to read. It's not a critical difference though, just something to be aware of. Mojo traits are already pretty useful, despite the language being in its early days. While Go philosophy is all about simplicity and tries to keep the features to a minimum, it's likely that we'll see more functionality added to Mojo traits in the future, making them even more powerful and enabling tons of different use cases.

Mojo Traits: How Do They Compare to Go Interfaces?

মোজো বৈশিষ্ট্য: তারা গো ইন্টারফেসের সাথে কীভাবে তুলনা করে?

Mojo-Eigenschaften: Wie vergleichen sie sich mit Go-Schnittstellen?

Rasgos de Mojo: ¿Cómo se comparan con las interfaces Go?

Traits Mojo : comment se comparent-ils aux interfaces Go ?

मोजो लक्षण: उनकी तुलना गो इंटरफेस से कैसे की जाती है?

Mojo の特性: Go インターフェイスとの比較は?

Mojo 특성: Go 인터페이스와 어떻게 비교됩니까?

Traços do Mojo: como eles se comparam às interfaces Go?

Особенности Mojo: как они соотносятся с интерфейсами Go?

Mojo Özellikleri: Go Arayüzleriyle Nasıl Karşılaştırılır?

Đặc điểm Mojo: Chúng so sánh với giao diện Go như thế nào?

Mojo 特征：它们与 Go 接口相比如何？

Cypherpunks Write Code: Len Sassaman & Remailers

সাইফারপাঙ্কস কোড লিখুন: লেন সাসামান এবং রিমেলার

Los cypherpunks escriben código: Len Sassaman y los remailers

Cypherpunks Kirjoita koodi: Len Sassaman & Remailers

Cypherpunks כותבים קוד: Len Sassaman & Remailers

サイファーパンクがコードを書く: レン・サッサマンとリメイラー

Cypherpunks Kokoma Code: Len Sassaman & Ba remailers

Cypherpunks Rašyti kodą: Len Sassaman & Remailers

Cypherpunks د لیکلو کوډ: لین ساسامان او ریمیلرز

Cypherpunks escrevem código: Len Sassaman e Remailers

Шифропанки пишут код: Лен Сассаман и ремейлеры

Cypherpunks Write Code: Len Sassaman සහ Remailers

ሳይፈርፓንክስ ኮድ ጽሓፍ: ሌን ሳሳማን & ሪሜይለርስ

Hi! If you read my previous article about why I chose Ruby, you know why I didn’t follow JS even though it was still deep in my memory after finishing the Calculator project and the whole Foundations from The Odin Project. Introduction to Ruby with The Odin Project I have to tell you that I couldn’t wait for that moment and was super excited to learn Ruby and to really see how Yukihiro “Matz” Matsumoto managed to make it so programmer-friendly, as many say. Getting Started: Ruby Installation and Documentation Firstly I had to install everything and it wasn’t difficult with TOP guide. After a short while, everything was set and ready to go. Firstly, I was introduced to Ruby documentation, which looked a little bit different from JS. (What would I expect, though?! It’s a different language! :D) It took me some time to get used to that. Especially when it comes to all methods and classes, at that point, I could tell the OOP lesson was approaching because it seemed different from what I was used to. Once you get the hang of everything, it becomes really easy to find the information you’re looking for. The next step was to learn what IRB is. It is a Ruby interactive model that lets you type your program in the console and run it without creating any files. It is a very useful thing that Rubyists use all the time, and I have liked it since the beginning as I didn’t need to open a browser to check my code every single time like I was doing with JS. Tackling the Basics: Data Types and Initial Challenges After I was sorted with all those, I was ready to tackle basic data types, and after a couple of Pomodoro sessions, my hype began to slow down. Why? It felt super boring! I felt as if I was doing JS from the beginning. I thought I’d done this before, so why waste time doing the same thing again? I understand that I am learning a new language, and I need to start from the basics, but c’moooon! Overcoming Boredom and Staying Motivated I’ll admit I was a LITTLE disappointed at first, but I had no choice but to stick to the plan and carry on. I knew it would get more exciting at some point, but I was only afraid not to lose motivation. Why would I? It took me already so long to get to this point that there is no chance I am stopping or changing my mind. I didn’t want to fight with my thoughts any longer at this point and just decided to put in more hours and focus harder as procrastination started to crippling in, especially between my Pomodoro sessions. The next lessons were about conditionals, loops, arrays, hashes, methods, and debugging. I cannot say it was the most exciting time, and at this time, I missed making some projects. I felt as if I was forgetting how to write code while learning how to write code. Strange, isn’t it? I hope that you know what I mean. Maybe there are more of you who have had the same struggles. I then approached Basic Ruby Projects, and this news made me happy. I was finally able to give it a try and solve some bigger exercises like I used with Java Script some time ago. Well, I can’t remember how long it took me to finish them, but it wasn’t too long before I got back to TOP lessons. From Basics to Object-Oriented Programming (OOP) The next one was object-oriented programming, which I couldn’t wait for. At that moment, I knew what it was going to be all about, more or less, and I was eager to try it. Moreover, I was really curious if it’s so difficult to grasp, as people sometimes say. Since then, I planned to push through the curriculum faster during the weekends, but something was always stopping me, like my car broke, and I had to buy another one as it wasn’t worth repairing my old one. Shortly after, my family wanted to visit me, and we were planning to go to Scotland for a week. I knew already that the time I wanted to spend on learning was limited that month. When we were there, I did my best to learn Ruby for 1 hour a day at least. After we came back and I dropped my family at the airport, my friend from Birmingham came to me for the weekend as he needed me to give him a hand fixing garden furniture he produced and sold to clients not far away from where I live. On top of that, my newly bought car decided to start leaking, and to save up money, I decided to fix it myself over another weekend. Guess what… By this point, I had already lost three weeks of productivity. I was a little bit mad and scared that I wouldn’t be able to get my routine going again, but fortunately, it seemed to start picking up nicely after I started again. I continued with OOP, which didn’t seem difficult. I could see the clear, organized approach, and I really liked it! I knew, however, that once I got to 1st bigger project using this, I would probably be stuck and have to return to these lessons. Well, that’s learning, isn’t it? Ruby vs. JavaScript: My Favorite Ruby Features Apart from time management, I knew Ruby was a great choice, and even though I still had JavaScript syntax in my brain, I could see how rewarding Ruby is. It was so easy to see how things are done in Ruby, and I can promise you that if you decide to learn this, you will have plenty of AHA and ‘’why couldn’t it be implemented to JS?!” moments. Look at these examples I liked the most so far: Range Operations: In Ruby, it’s super simple! (1..5).to_a And now, look at JavaScript: let range = Array.from({length: 5}, (v, k) => k + 1); Symbol vs string usage in hashes Ruby again makes it easier to read, especially in large objects: user = { name: "Alice", age: 25 } JavaScript: let user = { "name": "Alice", "age": 25 }; Another example is a case statement. I loved it since I found out about this for the first time. I finally didn’t need to use console.log, which was quite annoying. case language
when "Ruby"
  "Great choice!"
when "Python"
  "Not bad!"
else
  "Consider Ruby!"
end Javascript switch (language) {
  case "Ruby":
    console.log("Great choice!");
    break;
  case "Python":
    console.log("Not bad!");
    break;
  default:
    console.log("Consider Ruby!");
} Tips for Staying Motivated on Your Coding Journey It took more work to get to this point of The Odin Project. I would even say that the whole Foundation was easier than the beginning of Ruby. However, after these many lessons, my willingness to learn more has returned, and I want to push further. I also stopped procrastinating so much. If you are in a similar place with your learning schedule and feeling tired and thinking about doing something else, I encourage you not to give up! Really! Maybe it sounds blatant, and I might sound like a cheap coach or something, but it works. At the moment, I am working on a Mastermind project, and it is fun. Tic-Tac-Toe helped me to refresh all my knowledge about OOP, and it seems like Mastermind feels much more fun as, at this point, I know how to solve many problems. Keep going. Everything will click at some point! I’ll keep you updated after I’m done with another challenge. Hi! If you read my previous article about why I chose Ruby, you know why I didn’t follow JS even though it was still deep in my memory after finishing the Calculator project and the whole Foundations from The Odin Project . previous article The Odin Project Introduction to Ruby with The Odin Project I have to tell you that I couldn’t wait for that moment and was super excited to learn Ruby and to really see how Yukihiro “Matz” Matsumoto managed to make it so programmer-friendly, as many say. Yukihiro “Matz” Matsumoto Getting Started: Ruby Installation and Documentation Firstly I had to install everything and it wasn’t difficult with TOP guide. After a short while, everything was set and ready to go. Firstly, I was introduced to Ruby documentation, which looked a little bit different from JS. (What would I expect, though?! It’s a different language! :D) It took me some time to get used to that. Especially when it comes to all methods and classes, at that point, I could tell the OOP lesson was approaching because it seemed different from what I was used to. Once you get the hang of everything, it becomes really easy to find the information you’re looking for. The next step was to learn what IRB is. It is a Ruby interactive model that lets you type your program in the console and run it without creating any files. It is a very useful thing that Rubyists use all the time, and I have liked it since the beginning as I didn’t need to open a browser to check my code every single time like I was doing with JS. Tackling the Basics: Data Types and Initial Challenges After I was sorted with all those, I was ready to tackle basic data types, and after a couple of Pomodoro sessions, my hype began to slow down. Why? It felt super boring! I felt as if I was doing JS from the beginning. I thought I’d done this before, so why waste time doing the same thing again? I understand that I am learning a new language, and I need to start from the basics, but c’moooon! Overcoming Boredom and Staying Motivated I’ll admit I was a LITTLE disappointed at first, but I had no choice but to stick to the plan and carry on. I knew it would get more exciting at some point, but I was only afraid not to lose motivation. Why would I? It took me already so long to get to this point that there is no chance I am stopping or changing my mind. It took me already so long to get to this point I didn’t want to fight with my thoughts any longer at this point and just decided to put in more hours and focus harder as procrastination started to crippling in, especially between my Pomodoro sessions. The next lessons were about conditionals, loops, arrays, hashes, methods, and debugging. I cannot say it was the most exciting time, and at this time, I missed making some projects. I felt as if I was forgetting how to write code while learning how to write code. Strange, isn’t it? I hope that you know what I mean. Maybe there are more of you who have had the same struggles. I then approached Basic Ruby Projects, and this news made me happy. I was finally able to give it a try and solve some bigger exercises like I used with Java Script some time ago. Well, I can’t remember how long it took me to finish them, but it wasn’t too long before I got back to TOP lessons. From Basics to Object-Oriented Programming (OOP) The next one was object-oriented programming, which I couldn’t wait for. At that moment, I knew what it was going to be all about, more or less, and I was eager to try it. Moreover, I was really curious if it’s so difficult to grasp, as people sometimes say. Since then, I planned to push through the curriculum faster during the weekends, but something was always stopping me, like my car broke, and I had to buy another one as it wasn’t worth repairing my old one. Shortly after, my family wanted to visit me, and we were planning to go to Scotland for a week. I knew already that the time I wanted to spend on learning was limited that month. When we were there, I did my best to learn Ruby for 1 hour a day at least. After we came back and I dropped my family at the airport, my friend from Birmingham came to me for the weekend as he needed me to give him a hand fixing garden furniture he produced and sold to clients not far away from where I live. On top of that, my newly bought car decided to start leaking, and to save up money, I decided to fix it myself over another weekend. Guess what… By this point, I had already lost three weeks of productivity. I was a little bit mad and scared that I wouldn’t be able to get my routine going again, but fortunately, it seemed to start picking up nicely after I started again. I continued with OOP, which didn’t seem difficult. I could see the clear, organized approach, and I really liked it! I knew, however, that once I got to 1st bigger project using this, I would probably be stuck and have to return to these lessons. Well, that’s learning, isn’t it? Ruby vs. JavaScript: My Favorite Ruby Features Apart from time management, I knew Ruby was a great choice, and even though I still had JavaScript syntax in my brain, I could see how rewarding Ruby is. It was so easy to see how things are done in Ruby, and I can promise you that if you decide to learn this, you will have plenty of AHA and ‘’why couldn’t it be implemented to JS?!” moments. Look at these examples I liked the most so far: Range Operations: In Ruby, it’s super simple! (1..5).to_a (1..5).to_a And now, look at JavaScript: let range = Array.from({length: 5}, (v, k) => k + 1); let range = Array.from({length: 5}, (v, k) => k + 1); Symbol vs string usage in hashes Ruby again makes it easier to read, especially in large objects: user = { name: "Alice", age: 25 } user = { name: "Alice", age: 25 } JavaScript: let user = { "name": "Alice", "age": 25 }; let user = { "name": "Alice", "age": 25 }; Another example is a case statement. I loved it since I found out about this for the first time. I finally didn’t need to use console.log, which was quite annoying. case language
when "Ruby"
  "Great choice!"
when "Python"
  "Not bad!"
else
  "Consider Ruby!"
end case language
when "Ruby"
  "Great choice!"
when "Python"
  "Not bad!"
else
  "Consider Ruby!"
end Javascript switch (language) {
  case "Ruby":
    console.log("Great choice!");
    break;
  case "Python":
    console.log("Not bad!");
    break;
  default:
    console.log("Consider Ruby!");
} switch (language) {
  case "Ruby":
    console.log("Great choice!");
    break;
  case "Python":
    console.log("Not bad!");
    break;
  default:
    console.log("Consider Ruby!");
} Tips for Staying Motivated on Your Coding Journey It took more work to get to this point of The Odin Project. I would even say that the whole Foundation was easier than the beginning of Ruby. However, after these many lessons, my willingness to learn more has returned, and I want to push further. I also stopped procrastinating so much. If you are in a similar place with your learning schedule and feeling tired and thinking about doing something else, I encourage you not to give up! Really! Maybe it sounds blatant, and I might sound like a cheap coach or something, but it works. At the moment, I am working on a Mastermind project, and it is fun. Tic-Tac-Toe helped me to refresh all my knowledge about OOP, and it seems like Mastermind feels much more fun as, at this point, I know how to solve many problems. Keep going. Everything will click at some point! I’ll keep you updated after I’m done with another challenge.

Falling in Love with Ruby: Getting Started with The Odin Project

Surely, BitTorrent sounds like something familiar, right? It’s that famous file-sharing protocol that now works with the client uTorrent. Well, Bram Cohen, an American computer scientist, is the one who invented it —and more. He’s also considered an early cypherpunk, even if he wasn’t on the 90’s mailing list because he’s been dedicated to creating privacy-oriented and peer-to-peer (P2P) software. Born in 1975 in New York City, Cohen grew up in a family that nurtured his intellectual pursuits, with his father being a computer scientist. His fascination with computers began early; by the age of six, he was already learning to code in BASIC on a Timex Sinclair computer. This early exposure to programming set the foundation for his future innovations. During his high school years at Stuyvesant High School, Cohen excelled in mathematics and even qualified for the United States of America Mathematical Olympiad. Indeed, he’s said that he considers himself a mathematician in his own right. After graduating, he briefly attended SUNY Buffalo but soon left to dive into the tech industry, joining several dot-com startups during the 1990s. Before his groundbreaking work on BitTorrent, Cohen was involved in various projects, including MojoNation, a platform he co-developed with Jim McCoy —another early cypherpunk. This system was designed to allow users to securely share files by breaking them into encrypted pieces distributed across multiple computers, in a P2P manner. It was never fully operational, but this project would likely lay the groundwork for Cohen’s later creation of the BitTorrent protocol, which revolutionized file sharing and digital distribution. BitTorrent & Chia Cohen started to work on the BitTorrent software in 2001, but it wouldn’t be until 2004 that he founded the company BitTorrent Inc., along with his brother Ross Cohen and business partner Ashwin Navin. The protocol offers shutdown-resistant, efficient, and scalable file distribution by decentralizing the process. It works by breaking files into smaller pieces, which are then distributed among users (called peers) who download and upload these pieces simultaneously. This approach has allowed massive piracy to happen over the years, even though Cohen has said that wasn’t his intention. As it actually happened, however, the main advantage of BitTorrent is being a tool where file sharing is pretty hard to stop or block, no matter the file or country, because there are many peers involved. Previous services of this kind, like mp3.com and Napster, were shut down because they were centralized –unlike BitTorrent, which came to solve that issue, despite all odds. Its system was designed to distribute and share data directly among individual peers, without restrictions, in contrast to traditional methods like HTTP or FTP, which often rely on a single server. The first releases of the BitTorrent software by Cohen’s company were open-source and are still around, allowing widespread adoption and development by various developers and communities. Over time, aspects of the company’s BitTorrent technology became proprietary, particularly as the company behind it, BitTorrent, Inc. (later Rainberry, Inc.), sought to monetize the technology through various products and services​. https://www.youtube.com/watch?v=-DHFHYmaKS0 The rebranded client uTorrent, released in 2007, was no longer open-source. However, the BitTorrent protocol is open, and there are multiple alternative programs implementing the same protocol, some of them are open-source. For his part, Cohen left the company to co-found the Chia Network in 2017. This is a blockchain protocol designed with a focus on sustainability. Unlike cryptocurrencies like Bitcoin, which rely on energy-intensive Proof-of-Work (PoW) mechanisms, Chia uses its own consensus algorithm called Proof of Space and Time (PoST), created by Cohen. This method leverages unused storage space on users’ hard drives to “farm” Chia coins, rather than “mining” them with powerful computing hardware. The idea is to make the network eco-friendlier by utilizing existing resources rather than consuming excessive energy. However, large chunks of space (over 108 GB) and some degree of technical knowledge are required to become a farmer. Cohen and Cypherpunks Cohen is considered a cypherpunk by many, but he’s shared that he wasn’t on any cypherpunk lists, because he found “too many political rants, too little tech.” Beyond this, and maybe ironically, he’s been widely involved with other cypherpunks over the years. Len Sassaman, a privacy advocate and vocal cypherpunk (even a suspected candidate to be Satoshi Nakamoto), was his roommate by 2001 and helped him to create the annual CodeCon conference for hackers and technology enthusiasts in 2002. Cohen remembers that Len was a constant participant on the cypherpunk mailing list, and tried to make him publish BitTorrent pseudonymously. Besides Sassaman, several cypherpunks likely ended up participating in the CodeCon until the last one, in 2009. Hal Finney, the first-ever Bitcoin user, and creator of the system RPOW, gave a talk there in 2005, and Adam Back, now the Blockstream CEO, assisted in 2002. However, above all, Cohen’s creations have been reflecting his ideologies. BitTorrent, as a P2P file-sharing system, and Chia, as a crypto ecosystem, have been seen as tools that align with cypherpunk ideals, promoting the decentralization of data and providing users with more control over their digital privacy​ —and funds. Besides, for him, “cypherpunk” is “a bit of a catch-all term for Internet-related badassery,” and his own work “feels like a constant series of extreme heists, somehow bizarrely juxtaposed with it all happening while I lounge on my couch in sweat pants.” Cypherpunk Projects We can say that Bram Cohen is more of a lowkey cypherpunk, not as vocal about it as other members. However, his creations follow the same goals. BitTorrent, for instance, revolutionized file-sharing by decentralizing the process, making it virtually impossible to shut down. Unlike earlier systems like mp3.com and Napster, which relied on centralized servers that could be targeted and taken down by authorities, BitTorrent distributed the workload across many users. Its P2P network implies that there’s no single point of failure, making it incredibly resilient against shutdown attempts. This decentralized nature aligns perfectly with cypherpunk ideals, which champion privacy, freedom, and resistance to censorship. BitTorrent, and also the decentralized Chia, embody these principles by ensuring that information and transactions remain free-flowing and accessible, inside the devices of thousands, regardless of attempts to control it. Their design reflects the cypherpunk ethos of using technology to protect individual rights and maintain an open, uncensored Internet. A Directed Acyclic Graph (DAG) structure like Obyte also reflects those ideals. This is a truly decentralized platform, whose design allows transactions to be added directly by users, and it’s maintained by a whole global network of peers. The only other thing needed to avoid double-spending is Order Providers (OPs), who just provide their own transactions as a guide to order the rest, but don’t have further control over the network. This approach not only enhances decentralization but also aligns with the cypherpunk ethos of reducing reliance on centralized authorities and increasing user control over data and transactions. The platform's commitment to privacy and autonomy is evident in its features like self-sovereign identity and its own privacy coin (Blackbytes), allowing users to manage their data and engage in secure, private transactions. These attributes and many more make Obyte a practical tool for those who value the ideals of cypherpunks, such as the protection of personal information and the promotion of a decentralized digital economy. Read more from Cypherpunks Write Code series: Tim May & Crypto-anarchism
Wei Dai & B-money
Nick Szabo & Smart Contracts
Adam Back & Hashcash
Eric Hughes & Remailer
St Jude & Community Memory
Julian Assange & Wikileaks
Hal Finney & RPOW
John Gilmore & EFF
Satoshi Nakamoto & Bitcoin
Gregory Maxwell & Bitcoin Core
David Chaum & Ecash Featured Vector Image by Garry Killian/Freepik Photograph of Bram Cohen by Ijon/Wikimedia Surely, BitTorrent sounds like something familiar, right? It’s that famous file-sharing protocol that now works with the client uTorrent. Well, Bram Cohen, an American computer scientist, is the one who invented it —and more. He’s also considered an early cypherpunk, even if he wasn’t on the 90’s mailing list because he’s been dedicated to creating privacy-oriented and peer-to-peer (P2P) software. Born in 1975 in New York City, Cohen grew up in a family that nurtured his intellectual pursuits, with his father being a computer scientist. His fascination with computers began early ; by the age of six, he was already learning to code in BASIC on a Timex Sinclair computer. This early exposure to programming set the foundation for his future innovations. began early began early During his high school years at Stuyvesant High School, Cohen excelled in mathematics and even qualified for the United States of America Mathematical Olympiad. Indeed, he’s said that he considers himself a mathematician in his own right. After graduating, he briefly attended SUNY Buffalo but soon left to dive into the tech industry, joining several dot-com startups during the 1990s. he’s said he’s said After graduating, he briefly attended SUNY Buffalo but soon left to dive into the tech industry, joining several dot-com startups during the 1990s. Before his groundbreaking work on BitTorrent, Cohen was involved in various projects, including MojoNation, a platform he co-developed with Jim McCoy —another early cypherpunk. This system was designed to allow users to securely share files by breaking them into encrypted pieces distributed across multiple computers, in a P2P manner. It was never fully operational , but this project would likely lay the groundwork for Cohen’s later creation of the BitTorrent protocol, which revolutionized file sharing and digital distribution. fully operational fully operational BitTorrent & Chia Cohen started to work on the BitTorrent software in 2001, but it wouldn’t be until 2004 that he founded the company BitTorrent Inc., along with his brother Ross Cohen and business partner Ashwin Navin. The protocol offers shutdown-resistant, efficient, and scalable file distribution by decentralizing the process. It works by breaking files into smaller pieces, which are then distributed among users (called peers) who download and upload these pieces simultaneously. This approach has allowed massive piracy to happen over the years, even though Cohen has said that wasn’t his intention. As it actually happened, however, the main advantage of BitTorrent is being a tool where file sharing is pretty hard to stop or block, no matter the file or country, because there are many peers involved. Cohen has said that wasn’t his intention. Cohen has said that wasn’t his intention. As it actually happened, however, the main advantage of BitTorrent is being a tool where file sharing is pretty hard to stop or block, no matter the file or country, because there are many peers involved. Previous services of this kind, like mp3.com and Napster, were shut down because they were centralized –unlike BitTorrent, which came to solve that issue, despite all odds. Its system was designed to distribute and share data directly among individual peers, without restrictions, in contrast to traditional methods like HTTP or FTP, which often rely on a single server. The first releases of the BitTorrent software by Cohen’s company were open-source and are still around, allowing widespread adoption and development by various developers and communities. Over time, aspects of the company’s BitTorrent technology became proprietary, particularly as the company behind it, BitTorrent, Inc. (later Rainberry, Inc.), sought to monetize the technology through various products and services​. https://www.youtube.com/watch?v=-DHFHYmaKS0 https://www.youtube.com/watch?v=-DHFHYmaKS0 https://www.youtube.com/watch?v=-DHFHYmaKS0 The rebranded client uTorrent, released in 2007, was no longer open-source. However, the BitTorrent protocol is open, and there are multiple alternative programs implementing the same protocol, some of them are open-source. For his part, Cohen left the company to co-found the Chia Network in 2017. This is a blockchain protocol designed with a focus on sustainability. Unlike cryptocurrencies like Bitcoin, which rely on energy-intensive Proof-of-Work (PoW) mechanisms, Chia uses its own consensus algorithm called Proof of Space and Time (PoST), created by Cohen. For his part, Cohen left the company to co-found the Chia Network in 2017. This method leverages unused storage space on users’ hard drives to “farm” Chia coins, rather than “mining” them with powerful computing hardware. The idea is to make the network eco-friendlier by utilizing existing resources rather than consuming excessive energy. However, large chunks of space ( over 108 GB ) and some degree of technical knowledge are required to become a farmer. over 108 GB over 108 GB Cohen and Cypherpunks Cohen is considered a cypherpunk by many, but he’s shared that he wasn’t on any cypherpunk lists, because he found “too many political rants, too little tech.” Beyond this, and maybe ironically, he’s been widely involved with other cypherpunks over the years. he found he found Len Sassaman, a privacy advocate and vocal cypherpunk (even a suspected candidate to be Satoshi Nakamoto), was his roommate by 2001 a nd helped him to create the annual CodeCon conference for hackers and technology enthusiasts in 2002. suspected candidate suspected candidate nd helped him to create the annual CodeCon conference for hackers and technology enthusiasts in 2002. Cohen remembers that Len was a constant participant on the cypherpunk mailing list, and tried to make him publish BitTorrent pseudonymously. Besides Sassaman, several cypherpunks likely ended up participating in the CodeCon until the last one, in 2009. Cohen remembers Cohen remembers Hal Finney, the first-ever Bitcoin user, and creator of the system RPOW, gave a talk there in 2005, and Adam Back, now the Blockstream CEO, assisted in 2002. gave a talk gave a talk assisted assisted However, above all, Cohen’s creations have been reflecting his ideologies. BitTorrent, as a P2P file-sharing system, and Chia, as a crypto ecosystem, have been seen as tools that align with cypherpunk ideals, promoting the decentralization of data and providing users with more control over their digital privacy​ —and funds . BitTorrent, as a P2P file-sharing system, and Chia, as a crypto ecosystem, have been seen as tools that align with cypherpunk ideals, promoting the decentralization of data and providing users with more control over their digital privacy​ —and funds Besides, for him , “cypherpunk” is “a bit of a catch-all term for Internet-related badassery,” and his own work “feels like a constant series of extreme heists, somehow bizarrely juxtaposed with it all happening while I lounge on my couch in sweat pants.” for him for him Cypherpunk Projects We can say that Bram Cohen is more of a lowkey cypherpunk, not as vocal about it as other members. However, his creations follow the same goals. BitTorrent, for instance, revolutionized file-sharing by decentralizing the process, making it virtually impossible to shut down. Unlike earlier systems like mp3.com and Napster, which relied on centralized servers that could be targeted and taken down by authorities, BitTorrent distributed the workload across many users. Its P2P network implies that there’s no single point of failure, making it incredibly resilient against shutdown attempts. This decentralized nature aligns perfectly with cypherpunk ideals, which champion privacy, freedom, and resistance to censorship. BitTorrent, and also the decentralized Chia, embody these principles by ensuring that information and transactions remain free-flowing and accessible, inside the devices of thousands, regardless of attempts to control it. Their design reflects the cypherpunk ethos of using technology to protect individual rights and maintain an open, uncensored Internet. A Directed Acyclic Graph (DAG) structure like Obyte also reflects those ideals. This is a truly decentralized platform, whose design allows transactions to be added directly by users, and it’s maintained by a whole global network of peers. The only other thing needed to avoid double-spending is Order Providers (OPs), who just provide their own transactions as a guide to order the rest, but don’t have further control over the network. A Directed Acyclic Graph (DAG) structure like Obyte also reflects those ideals. This is a truly decentralized platform, whose design allows transactions to be added directly by users, and it’s maintained by a whole global network of peers. Obyte Obyte This approach not only enhances decentralization but also aligns with the cypherpunk ethos of reducing reliance on centralized authorities and increasing user control over data and transactions. The platform's commitment to privacy and autonomy is evident in its features like self-sovereign identity and its own privacy coin ( Blackbytes ), allowing users to manage their data and engage in secure, private transactions. These attributes and many more make Obyte a practical tool for those who value the ideals of cypherpunks, such as the protection of personal information and the promotion of a decentralized digital economy. self-sovereign identity self-sovereign identity Blackbytes Blackbytes Read more from Cypherpunks Write Code series: Read more from Cypherpunks Write Code series: Tim May & Crypto-anarchism Wei Dai & B-money Nick Szabo & Smart Contracts Adam Back & Hashcash Eric Hughes & Remailer St Jude & Community Memory Julian Assange & Wikileaks Hal Finney & RPOW John Gilmore & EFF Satoshi Nakamoto & Bitcoin Gregory Maxwell & Bitcoin Core David Chaum & Ecash Tim May & Crypto-anarchism Tim May & Crypto-anarchism Tim May & Crypto-anarchism Tim May & Crypto-anarchism Wei Dai & B-money Wei Dai & B-money Wei Dai & B-money Wei Dai & B-money Nick Szabo & Smart Contracts Nick Szabo & Smart Contracts Nick Szabo & Smart Contracts Nick Szabo & Smart Contracts Adam Back & Hashcash Adam Back & Hashcash Adam Back & Hashcash Adam Back & Hashcash Eric Hughes & Remailer Eric Hughes & Remailer Eric Hughes & Remailer Eric Hughes & Remailer St Jude & Community Memory St Jude & Community Memory St Jude & Community Memory St Jude & Community Memory Julian Assange & Wikileaks Julian Assange & Wikileaks Julian Assange & Wikileaks Julian Assange & Wikileaks Hal Finney & RPOW Hal Finney & RPOW Hal Finney & RPOW Hal Finney & RPOW John Gilmore & EFF John Gilmore & EFF John Gilmore & EFF John Gilmore & EFF Satoshi Nakamoto & Bitcoin Satoshi Nakamoto & Bitcoin Satoshi Nakamoto & Bitcoin Satoshi Nakamoto & Bitcoin Gregory Maxwell & Bitcoin Core Gregory Maxwell & Bitcoin Core Gregory Maxwell & Bitcoin Core Gregory Maxwell & Bitcoin Core David Chaum & Ecash David Chaum & Ecash Featured Vector Image by Garry Killian/Freepik Featured Vector Image by Garry Killian/ Freepik Freepik Freepik Photograph of Bram Cohen by Ijon/ Wikimedia Photograph of Bram Cohen by Ijon/ Wikimedia Wikimedia

Cypherpunks Write Code: Bram Cohen & BitTorrent

Los ciberpunks escriben código: Bram Cohen y BitTorrent

Cypherpunks کد را می نویسد: برام کوهن و بیت تورنت

I Cypherpunk scrivono il codice: Bram Cohen e BitTorrent

サイファーパンクがコードを書く: Bram Cohen と BitTorrent

Cypherpunks кодты жазады: Брам Коэн және BitTorrent

사이퍼펑크가 코드를 쓴다: 브램 코헨과 비트토렌트

Cypherpunks Manoratra Code: Bram Cohen & BitTorrent

Cypherpunks пишуваат код: Брам Коен и BitTorrent

Cypherpunks Ngwala Khoutu: Bram Cohen & BitTorrent

ሳይፈርፓንክስ ኮድ ጽሓፍ: ብራም ኮሄን & ቢትቶረንት።

Şifrler kod ýazýarlar: Bram Kohen we BitTorrent

I-Cypherpunks Bhala Ikhodi: Bram Cohen & BitTorrent

How to Waste $5000 on Personal Growth

The Curse of Pygmalion - What Would An Ideal AR/VR Device Look Like?

পিগম্যালিয়নের অভিশাপ - একটি আদর্শ এআর/ভিআর ডিভাইস দেখতে কেমন হবে?

Der Fluch von Pygmalion – Wie würde ein ideales AR/VR-Gerät aussehen?

La maldición de Pigmalión: ¿cómo sería un dispositivo AR/VR ideal?

La malédiction de Pygmalion – À quoi ressemblerait un appareil AR/VR idéal ?

पिग्मेलियन का अभिशाप - एक आदर्श AR/VR डिवाइस कैसा दिखेगा?

ピグマリオンの呪い - 理想的な AR/VR デバイスとはどのようなものでしょうか?

피그말리온의 저주 - 이상적인 AR/VR 장치는 어떤 모습일까요?

A Maldição de Pigmalião – Como seria um dispositivo AR/VR ideal?

Проклятие Пигмалиона: как должно выглядеть идеальное AR/VR-устройство?

Pygmalion'un Laneti - İdeal Bir AR/VR Cihazı Nasıl Görünür?

Lời nguyền của Pygmalion - Thiết bị AR/VR lý tưởng sẽ trông như thế nào?

皮格马利翁的诅咒——理想的 AR/VR 设备是什么样的？

Stories, News & Mentions about MOOJO

Moojo’s Stories on HackerNoon