#brainfuck compiler

[faebiebot]

Ive successfully made a Brainfuck compiler!

First I started out getting my program to read from a file

but once I knew how to write a file it was trivial to convert the Brainfuck code to C code. there's a bit of file path hard coding i'm not exactly happy with but i'm probably the only person that's gonna use this compiler.

Of course initial drafts of the compiler wrote some uncompilable code but once I got rid of the typos Its a fully functional.

I think...

[sed-official]

im good! was just eating dinner (chicken and pasta), and have had a great rest day today with my dogs. i did nothing of note! yippee!

how are you?

echo -n "meo" && while [ 1 ]; do echo -n "w"; done

- @sed-official

MEOWWWWWWWWWWWWWWWW

hi sed how are you

[piratesexmachine420]

Because of the way floating point numbers work, as they get larger there comes a point where you actually can't increment them. They simply get too imprecise to encode a difference of 1.0f. Which is to say, for sufficiently big (or, I guess "magnitudinous") values, x == x + 1. For high-precision floats, like IEEE 754 double-precision and quadruple-precision and x87 extended-precision floats (among others), these thresholds are really quite large -- in the trillions at the lowest -- but for the humble 32-bit float it's not tremendously big, only 16,777,216 (or -16,777,216).

Now, when it comes to programs that do lots and lots of incrementing and decrementing, what does my mind go to? Brainfuck. Brainfuck is built almost entirely around incrementing and decrementing. Historically, this has been a source of problems for implementers, as there's no immediately obvious way to handle overflows or underflows. Should the cell array wrap around? Should the program simply segfault? Should cells be 8-bit, or bigger? Should we simply continue allocating memory as the cell pointer gets further from the origin? How should we handle negative cell pointer values?

Well, we can kill ...one bird with ...another, already dead bird here: make everything use 32-bit floats! We don't have to worry about overflows anymore, the cell pointer will just get "stuck" after a while! This also really simplifies the memory model: we can just statically allocate 33,554,433 doublewords on program startup (mere megabytes) and be assured the cell pointer will never escape into uninitialized memory. We don't have to worry about the cell values themselves either -- they'll bang up against the same thresholds.

I wrote a highly unsophisticated compiler (with NASM as an assembler backend) several months ago using this idea, and I think I'd like to come back to it -- there's a funny sort of inelegant elegance here.

[strixton]

Oh, you're wondering what an advanced computer science college class does when the professor does not want to give a full lecture the day before spring break starts?

Well, he started the lecture by having us listen to the DanDaDan intro theme (full version, not just the intro bit)

Then he showed us BrainFuck (he teaches it in every class he teaches for a free fun day lesson)

And now he's speed running building a brainfuck compiler in Java on his own (we are timing him)

We chose forcing him to speedrun a compiler over discussing upcoming anime (a very common discussion topic in class, along side indie games and Taylor swift)

[quantummechanist]

My Esoteric Programming Language Synopsis

Been looking into esoteric programming languages, or programming languages whose purpose is NOT to make a programmer's life easier, but rather to be weird and often confusing. Here are my reviews:

<>< (Fish): This language revolves around the moving a pointer around the program itself, which is read as a 2 dimensional grid of characters. The pointer moves to the right by default, but you can change its direction with the arrow-looking characters (<,>,^,v). You can also reflect the instruction pointer with the mirror-looking characters (|,_,/,\\), which reflect the arrow the direction that makes sense based on what way it is going and the geometry of the characters. On top of this, the language is stack-based. For those who don't recall the first few pages of Homestuck, a stack is a data structure that stores a list of values like an array, except the only accessible datum in the stack is the most recently entered one. Programmers have no business using stacks in the year 2023. Other neat details include the trampoline instruction (!) which jumps over a spot in the grid, and because you need to use a stack, to print a value from code, you need to write it in the code backwards. Also when you get an error, the compiler says "Something smells fishy..." Difficulty 3/10

Brainfuck: Brainfuck was made by a man trying to make the smallest programming language compiler he could. The program instructions rely on an arbitrarily large 1 dimensional array of numbers. Brainfuck has 8 single-character commands, and all other characters are treated as comments. This is a brainfuck program to write "Hello World":

+[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.[<->-]<-.>

Difficulty 9/10

Hexagony: Like <><, Hexagony works by sending a pointer along the program, treating it like a grid of characters. The difference is that Hexagony programs are on a hexagonal grid. This is Hello World in Hexagony:

Difficulty 8/10 (I cannot wrap my head around this one)

INTERCAL: Compiler Language With No Pronounceable Acronym, or INTERCAL, was one of the first esoteric programming languages, created in 1972. The language was designed to make common operations needlessly difficult, while adding keywords for other operations to make the whole thing unpleasant to look at. There is a keyword “PLEASE” that doesn’t do anything, although if you don’t include enough “PLEASE” commands, the compiler will give an error stating your program is not polite enough. Unlike most of the programming languages on this list, INTERCAL is too slow when compiled to be used practically. In 1992 a journalist tested the speed of Intercal against C. In C, it took less than a second to compute all the prime numbers up to 65536. In INTERCAL, it took over 17 hours. Difficulty: 8/10 LOLCODE: The syntax of LOLCODE is inspired by “lolspeak,” the English dialect of lolcat captions. Every LOLCODE program begins with “HAI” and ends with “KTHXBYE”. To import library STDIO, use the command “CAN HAZ STDIO?” The underlying structure of LOLCODE is actually fairly standard, which makes this esolang pretty accessible.

Difficulty: 1/10

Malbolge: How do you print “Hello, World” in Malbolge?

(=<`#9]~6ZY327Uv4-QsqpMn&+Ij"'E%e{Ab~w=_:]Kw%o44Uqp0/Q?xNvL:`H%c#DD2^WV>gY;dts76qKJImZkj

Malbolge was designed to be the most difficult programming language in existence. The language determines which of the eight available instructions to execute by adding the current instruction to the current instruction’s index in memory, modulo 94. There are no arithmetic operators except for the *crazy operator*, a Malbolge original that takes two numbers in their ternary form and determines the result digit by digit using an unintuitive table. The crazy operator is not commutative, and is your only arithmetic operation. Whenever an instruction is executed, it is encrypted so that it will not do the same thing next time. Due to the complexity of Malbolge, a turing complete version does not currently exist, limited by the size of programs allowable.

Difficulty: 20/10

[devnews]

Build a high-performance Brainf**k JIT and AOT compiler on top of C# type system

What is Brainfuck? Brainfuck is a very simple, Turing-complete programming language devised by Urban Müller in 1993. Its simplicity is remarkable: a program can be written using just eight symbols. If we were to express it in a C-like way, it would look like this: Symbol Meaning > ++ptr < --ptr + ++*ptr - --*ptr . putchar(*ptr) , *ptr = getchar() [ while (*ptr) { ] } All you need is a…

[my-blog-is-a-sideblog]

No I'm just programmed in a weird language

[lillys-shadow]

tehe I wrote an article

[amitsaini012]

Top 15 Weird Programming Languages In Use in 2024

Programming languages have come a long way since the early days of computer science. While mainstream languages like C, Java, and Python continue to dominate software development, there are plenty of more obscure and unconventional options out there. These "weird" languages often prioritize things like ease of use, minimalism, or just plain fun over practical application. Some are little more than hobbyist projects, while others have managed to carve out a niche despite their oddities. In 2024, programmers will have more choice than ever when it comes to selecting a language for their next project. Whether they're looking to experiment with something new or just have a laugh, these 15 weird programming languages demonstrate the creative fringe of modern computer programming. Though not suited for large-scale software engineering, they highlight the endless possibilities in language design.

Note: If you are struggling with your programming assignment, then you can get the best programming assignment help from our experts. 

1. Brainfuck 

One of the esoteric programming languages, Brainfuck consists of only 8 single-character commands. Programs look like long sequences of +++++++--<>, which is where the name comes from. It's challenging to write anything useful given the extreme minimalism.

2. Velato 

This language uses MIDI files as source code. Programs are literally music that gets compiled into executables. Debugging means listening to your code and fixing sour notes.

3. Chef 

Programs in Chef look like cooking recipes. Variables are ingredients, mixing them together follows the syntax, and executing the program requires "baking" the final recipe. A taste of computing for Food Network fans.

4. LOLCODE 

Inspired by the LOLcat meme, LOLCODE has verbose keywords like VISIBLE, GIMMEH, and OMGWTF. Semicolons are replaced by the phrase "NOW GTFO". Strange as it is, LOLCODE can actually be used to build applications.

5. Malbolge 

Malbolge was named after the eighth circle of hell in Dante's Inferno, and it was made to be very hard to program in. Its language is based on encryption, which is hard to understand, and each command can only access a small group of registers and memory places. It is more of a virtual torture device than a language.

6. Shakespeare 

This esoteric language aims to make programs appear like Shakespearean plays. Variables are cast as characters, IF statements become soliloquies, and functions act out scenes. The results are halfway between software and literature.

7. Emojicode 

Feeling expressive? Emojicode lets you construct variables, functions, loops, and other programming fundamentals out of emoji symbols. You'll be coding smiles, winks, and kisses in no time.

8. Piet 

Named after abstract artist Piet Mondrian, this color-based language has programs that look like abstract paintings. Different colors represent coding elements like variables or loops. Placement on the canvas determines logic flow.

9. Perl 

One of the old standbys of scripting languages, Perl has fallen out of fashion due to its dense syntax and orthogonality. Reading Perl code feels a bit like decoding an ancient hieroglyphic text these days.

10. INTERCAL 

Developed in the 1970s as a parody of other languages' cryptic syntax, INTERCAL is deliberately full of obtuse and nonsensical keywords that make writing sensible programs a fool's errand. More an academic curiosity than usable language now.

11. Befunge 

The source code for Befunge programs looks like a ASCII game map. Instructions execute left to right, top to bottom or can jump to new points on the map. Strange by nature and design, it's tough to wrap your head around Befunge.

12. MATLAB 

While not that exotic, MATLAB draws criticism for using 1-based indexing instead of the 0-based indexes common to C and other languages. This disconnect from programming norms qualifies MATLAB for weird language status.

13. IDL 

Like MATLAB, IDL feels out of place because variables have to be explicitly declared before use. Due to this lack of dynamism and other limitations, IDL is often described as archaic by modern programmers.

14. COBOL 

Few languages seem as foreign to modern coders as COBOL, which powers critical legacy systems. Its wordy syntax and niche application domain make COBOL programming an oddity.

15. HQ9+ 

This minimalist joke language has only 4 instructions - H prints "Hello", Q prints its own source code, 9 prints the lyrics to 99 Bottles of Beer, and + increments the accumulator. Vast programs are possible with those building blocks!

Conclusion 

While unusual languages like those discussed above probably won't be powering the next great startup or operating system, they demonstrate that programming can encompass more than practical software engineering. Some weird languages like Velato turn code into music. Others like Chef and LOLCODE find the aesthetics in programming. And languages like Brainfuck and INTERCAL push minimalism and obfuscation to their limits. Most importantly, these esoteric languages show that even in computing, creativity comes in surprising packages. Weird languages keep pushing the boundaries and possibilities of programming itself. Even though few of us will write production software in Shakespeare or Emojicode, these novel languages represent the vanguard of creative expression through code. Their very existence highlights that computing is as much about human expression as logical rigor. So while businesses will stick to Python and Java for now, these weird languages continue to flex the diversity and range of programming possibilities.

[this-week-in-rust]

This Week in Rust 476

Hello and welcome to another issue of This Week in Rust! Rust is a programming language empowering everyone to build reliable and efficient software. This is a weekly summary of its progress and community. Want something mentioned? Tag us at @ThisWeekInRust on Twitter or @ThisWeekinRust on mastodon.social, or send us a pull request. Want to get involved? We love contributions.

This Week in Rust is openly developed on GitHub. If you find any errors in this week's issue, please submit a PR.

Updates from Rust Community

Foundation

A Q4 Recap & 2022 Reflection from Rebecca Rumbul

Project/Tooling Updates

rust-analyzer changelog #162

fltk-rs in 2022

shuttle - Release v0.8.0

This Week in Fyrox

gitoxide - The year in retrospective, and what's to come

The AeroRust community - 3 years birthday (and the roadmap for 2023)

SeaQuery 0.28.0 - A dynamic query builder for SeaORM

Databend 2022 Recap

Observations/Thoughts

State Machines III: Type States

Rust — vim — code completion

How to Test

Embedded Rust and Embassy: DMA Controllers

Parsing TFTP in Rust

Rustdoc JSON in 2022

From PHP to Rust: Migrating a REST API between these two languages. (Part I)

React + Rust + Wasm: Play an Animated 3D Model

Open Source Grindset Explained (with a Rust example)

Rust Walkthroughs

Building a Simple DB in Rust - Part 1

Microservices with Rust and WASM using Fermyon

Compiling Brainfuck code - Part 4: A Static Compiler

Rusty Circuit Breaker 🦀

Zero-dependency random number generation in Rust

Miscellaneous

Rust 101: an open-source university course

[video] If Rust Compiles, It WORKS (Testing not needed 📚)

[video] Introduction to Axum

[video] Ergonomic APIs for hard problems - Raph Levien

Crate of the Week

This week's crate is Sniffnet, a cross-platform GUI application to analyze your network traffic.

Thanks to Gyuly Vgc for the suggestion!

Please submit your suggestions and votes for next week!

Call for Participation

Always wanted to contribute to open-source projects but did not know where to start? Every week we highlight some tasks from the Rust community for you to pick and get started!

No calls for participation this week. Keep an eye out for more places to contribute next week!

If you are a Rust project owner and are looking for contributors, please submit tasks here.

Updates from the Rust Project

291 pull requests were merged in the last week

CFI: monomorphize transparent ADTs before typeid

account for match expr in single line

account for macros in const generics

account for multiple multiline spans with empty padding

adjust message on non-unwinding panic

allow trait method paths to satisfy const Fn bounds

always suggest as MachineApplicable in recover_intersection_pat

detect diff markers in the parser

detect when method call on LHS might be shadowed

dont use --merge-base during bootstrap formatting subcommand

emit fewer errors on invalid #[repr(transparent)] on enum

encode spans relative to the enclosing item -- enable on nightly

error parsing lifetime following by Sized and message + between them

fix confusing diagnostic when attempting to implementing trait for tuple

format only modified files

on unsized locals with explicit types suggest &

only deduplicate stack traces for good path bugs

give the correct track-caller location with MIR inlining

implement allow-by-default multiple_supertrait_upcastable lint

improve heuristics whether format_args string is a source literal

make trait/impl where clause mismatch on region error a bit more actionable

merge multiple mutable borrows of immutable binding errors

partially fix explicit_outlives_requirements lint in macros

properly calculate best failure in macro matching

provide a better error and a suggestion for Fn traits with lifetime params

provide local extern function arg names

recover fn keyword as Fn trait in bounds

remove unreasonable help message for auto trait

silence knock-down errors on [type error] bindings

suggest Pin::as_mut when encountering borrow error

suggest impl Iterator when possible for _ return type

suggest rewriting a malformed hex literal if we expect a float

suppress errors due to TypeError not coercing with inference variables

trim more paths in obligation types

miri: cargo-miri: use rustc to determine the output filename

miri: handle unknown targets more gracefully

miri: simplify path joining code a bit

miri: support using a JSON target file

miri: tweaks to retag diagnostic handling

use some more const_eval_select in pointer methods for compile times

more inference-friendly API for lazy

more verbose Debug implementation of std::process:Command

add #[inline] markers to once_cell methods

unify id-based thread parking implementations

available_parallelism:gracefully handle zero value cfs_period_us

catch panics/unwinding in destruction of thread-locals

cargo: asymmetric tokens

cargo: reasons for rebuilding

clippy: fix false negative in needless_return

clippy: fix match_single_binding suggestion introducing an extra semicolon

clippy: move mutex_atomic to restriction

rust-analyzer: derive Hash

rust-analyzer: enum variant discriminants hints

rust-analyzer: diagnose private assoc item accesses

rust-analyzer: diagnose private field accesses

rust-analyzer: implement yeeting

rust-analyzer: fall back to inaccessible associated functions and constants if no visible resolutions are found

rust-analyzer: improve exit point highlighting for for and while loops in tail position

rust-analyzer: merge multiple intersecting ranges

rust-analyzer: prefix prelude items whose name collides in current scope

rust-analyzer: type check unstable try{} blocks

rust-analyzer: support multi-character punct tokens in MBE

rust-analyzer: write down adjustments introduced by binary operators

Rust Compiler Performance Triage

Fairly busy week with some massive performance improvements at the expense of some significant albeit smaller regressions. The main wins came in a long-standing PR from @cjgillot to enable encoding spans in metadata relative to their enclosing item. This causes more work in full compilation which causes some regressions up to 5% but can lead to very large wins in incremental compilation scenarios (up to ~70%). For example, the clap crate compiles 68% faster after a small 1 line change than it did previously.

Triage done by @rylev. Revision range: b38a6d..b43596

Summary:

(instructions:u) mean range count Regressions ❌ (primary) 1.6% [0.3%, 4.6%] 97 Regressions ❌ (secondary) 1.8% [0.2%, 7.6%] 60 Improvements ✅ (primary) -9.7% [-68.7%, -0.2%] 53 Improvements ✅ (secondary) -1.7% [-15.3%, -0.1%] 62 All ❌✅ (primary) -2.4% [-68.7%, 4.6%] 150

1 Regressions, 1 Improvements, 4 Mixed; 1 of them in rollups 47 artifact comparisons made in total

Full report here

Approved RFCs

Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:

No RFCs were approved this week.

Final Comment Period

Every week, the team announces the 'final comment period' for RFCs and key PRs which are reaching a decision. Express your opinions now.

RFCs

No RFCs entered Final Comment Period this week.

Tracking Issues & PRs

[disposition: merge] Only include stable lints in rustdoc::all group

[disposition: merge] Don't derive Debug for OnceWith & RepeatWith

[disposition: merge] PhantomData layout guarantees

[disposition: merge] Add O(1) Vec -> VecDeque conversion guarantee

[disposition: merge] Stabilize ::{core,std}::pin::pin!

[disposition: merge] Stabilize main_separator_str

[disposition: merge] Loosen the bound on the Debug implementation of Weak.

New and Updated RFCs

No New or Updated RFCs were created this week.

Call for Testing

An important step for RFC implementation is for people to experiment with the implementation and give feedback, especially before stabilization. The following RFCs would benefit from user testing before moving forward:

No RFCs issued a call for testing this week.

If you are a feature implementer and would like your RFC to appear on the above list, add the new call-for-testing label to your RFC along with a comment providing testing instructions and/or guidance on which aspect(s) of the feature need testing.

Upcoming Events

Rusty Events between 2023-01-04 - 2023-02-01 🦀

Virtual

2023-01-04 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

2023-01-04 | Virtual (Stuttgart, DE) | Rust Community Stuttgart

Rust-Meetup

2023-01-05 | Virtual (Charlottesville, VA, US) | Charlottesville Rust Meetup

Part 2: Exploring USB with Rust

2023-01-10 | Virtual (Dallas, TX, US) | Dallas Rust

Second Tuesday

2023-01-11 | Virtual (Boulder, CO, US) | Boulder Elixir and Rust

Monthly Meetup

2023-01-12 | Virtual (San Francisco, CA, US; Stockholm, SE; New York, NY US) | Microsoft Reactor San Francisco | Microsoft Reactor New York

Crack code interview problems in Rust - Ep. 1 | Stockholm Mirror | New York Mirror

2023-01-12 | Virtual (Nürnberg, DE) | Rust Nuremberg

Rust Nürnberg online

2023-01-14 | Virtual | Rust GameDev

Rust GameDev Monthly Meetup

2023-01-16 | Virtual (San Francisco, CA, US; São Paulo, BR; New York, NY, US) | Microsoft Reactor San Francisco and Microsoft Reactor São Paulo and Microsoft Reactor New York

Primeros pasos con Rust - Qué es y Configuración el entorno de desarrollo | São Paulo Mirror | New York Mirror

2023-01-17 | Virtual (Berlin, DE) | OpenTechSchool Berlin

Rust Hack and Learn

2023-01-17 | Virtual (San Francisco, CA, US; São Paulo, BR, New York, NY, US) | Microsoft Reactor San Francisco and Microsoft Reactor São Paulo and Microsoft Reactor New York

Primeros pasos con Rust - Creación del primer programa de Rust | *São Paulo Mirror | New York Mirror

2023-01-17 | Virtual (Washington, DC, US) | Rust DC

Mid-month Rustful

2023-01-18 | Virtual (San Francisco, CA, US; São Paulo, BR; New York, NY US) | Microsoft Reactor San Francisco and Microsoft Reactor São Paulo and Microsoft Reactor New York

Primeros pasos con Rust: QA y horas de comunidad | Sao Paulo Mirror | New York Mirror

2023-01-18 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Rust Study/Hack/Hang-out

2023-01-26 | Virtual (Charlottesville, VA, US) | Charlottesville Rust Meetup

Rust Lightning Talks!

2023-01-31 | Virtual (Dallas, TX, US) | Dallas Rust

Last Tuesday

2023-02-01 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

Asia

2023-01-15 | Tokyo, JP | Tokyo Rust Meetup

Property-Based Testing in Rust

Europe

2023-01-12 | Enschede, NL | Dutch Rust Meetup

Rust Meetup - Subject TBA

2023-01-20 | Stuttgart, DE | Rust Community Stuttgart

OnSite Meeting

2023-01-25 | Paris, FR | Rust Paris

Rust Paris meetup #55

North America

2023-01-05 | Lehi, UT, US | Utah Rust

Lightning Talks 'n' Chill (a.k.a. Show & Tell), with Pizza!

2023-01-09 | Minneapolis, MN, US | Minneapolis Rust Meetup

Happy Hour and Beginner Embedded Rust Hacking Session (#2!)

2023-01-11 | Austin, TX, US | Rust ATX

Rust Lunch

2023-01-17 | San Francisco, CA, US | San Francisco Rust Study Group

Rust Hacking in Person

2023-01-26 | Copenhagen, DK | Copenhagen Rust group

Rust Hack Night #32

2023-01-26 | Lehi, UT, US | Utah Rust

Building a Rust Playground with WASM and Lane and Food!

If you are running a Rust event please add it to the calendar to get it mentioned here. Please remember to add a link to the event too. Email the Rust Community Team for access.

Jobs

Please see the latest Who's Hiring thread on r/rust

Quote of the Week

You haven’t “fooled” rustc, you are using unsafe code. Unsafe code means that all you can do is fool yourself.

– Frank Steffahn on rust-users

Thanks to Quine Dot for the suggestion!

Please submit quotes and vote for next week!

This Week in Rust is edited by: nellshamrell, llogiq, cdmistman, ericseppanen, extrawurst, andrewpollack, U007D, kolharsam, joelmarcey, mariannegoldin, bennyvasquez.

Email list hosting is sponsored by The Rust Foundation

Discuss on r/rust

[technocreature]

10 Worst Programming Languages on planet

Introduction

Programming languages are essential tools that empower developers to create innovative solutions. In this article, we will dive into the 10 programming languages that are considered the worst in terms of their complexities, limitations, and overall user experience.

1. COBOL: The Relic of the Past

COBOL (Common Business-Oriented Language) was designed in the late 1950s to handle business data processing. While it served its purpose well in its heyday, COBOL has become outdated and un widely used in this today's time. Its verbose syntax, lack of modern features, and limited support make it a challenging language to work with, particularly for beginners. 1.1 Legacy Systems and COBOL COBOL's main strength lies in its ability to handle legacy systems that have been in operation for decades. Many large organizations still rely on COBOL code to process critical business operations. However, due to its outdated nature, finding developers proficient in COBOL is becoming increasingly difficult, leading to compatibility and maintenance issues. 1.2 The Learning Curve of COBOL For beginners, COBOL's steep learning curve can be overwhelming. Its verbose syntax and unconventional coding style make it less intuitive compared to more modern languages. As a result, developers often find it frustrating and time-consuming to write and maintain COBOL code.  

2. INTERCAL: The Programming Language from Hell

INTERCAL, short for Compiler Language With No Pronounceable Acronym, is a deliberately obfuscated programming language created as a parody. It was designed to be as confusing and unreadable as possible, making it a nightmare for programmers to work with. 2.1 An Esoteric Programming Language INTERCAL is an example of an esoteric programming language, which focuses on challenging conventional programming practices. Its bizarre syntax, such as using statements like "PLEASE" and "DO NOT" instead of more common constructs, makes it intentionally difficult to comprehend and maintain. 2.2 The Quirky Nature of INTERCAL One of the defining features of INTERCAL is its love for randomness. The language encourages the use of unpredictable elements, including unconventional variable names and random program behavior, which adds another layer of complexity and confusion for programmers.

3. Brainfuck: Programming for the Adventurous

Brainfuck is an esoteric programming language known for its minimalistic design and extreme simplicity. It was created to challenge programmers and push the boundaries of what can be achieved with the fewest possible commands. 3.1 A Language of Minimalism Brainfuck consists of only eight commands: "+", "-", ">", " Read the full article

[piratesexmachine420]

Ehhh should I call an ambulance? You're writing assembly BY HAND?

Are you clinically insane or what?

Lol yeah x86 is an abomination -- we should've moved to ARM or PowerPC or something yesterday.

I just thought it'd be an instructive exercise to get down in the trenches for a sec -- I'm learning a lot about x64 opcodes, the System V ABI and all sorts of neat stuff. I'm hoping that in the next couple days I'll be able to write a little brainfuck compiler from scratch.

[pl-tournament]

Programming Language Showdown

currentStatus = "Brief intermission before Round 2"

Welcome to the programming language showdown!

(current results)

Here's the rules/faq:

Propaganda is allowed, tag me and I'll probably reblog it, yell about why powerpoint is a superior development environment to brainfuck or something

A programming language is any interface for developing a program or system, that is written/used via software, and is turing complete. Some examples:

Python, yes this is a programming language

Machine code, yes this is also a programming language

Minecraft redstone, yes this is also a programming language

Microsoft PowerPoint, yes this is also a programming language

A physical circuit, no this is not a programming language

A banana, no this is also not a programming language

Additionally, different versions of the same language are not different, even if they're significantly different, e.g. Python 2 and 3

Different flavours or versions of a language are different, however, provided they are compiled/transpiled/interpreted/written differently to each other, e.g. TypeScript and JavaScript are different langs

Be nice to eachother, and also to me, this is my first time running a tournament so uh, let's figure it out together hey?

The official name for Programming Langs is PLorbos.

[ammcgee-author]

188. People Will Love You, When They Understand You

Love, it begins with you and me.

No grandeur, no innovation.

Don’t get upset over the price of your dreams. Imagine.

Employment can be an actual job.

Injustice turns the concept of the smartphone upside down.

Screaming without the internet is like torture without the prisoner.

The better the misdeed — The better the Murder.

Soon, existence will be gone — so it’s ok to multiply.

Don’t forget that you are feeling dead inside.

Keep sharing. keep working. Consider Magic. A person who lives amongst romance, lives amongst adventure.

Make sure that everyone is aware that you are accepted, glamorous, and seek to be quotable.

You are a fuck geek.

How did unaccompanied grandmothers become hypocritical?

Being average is a lot like being a salesman. Librarians always lose.

Can rich people unleash the collapse of civilization as we know it?

A thing that appears to be too fantastic to be decided, very often is.

The Internet is the most underwhelming idea anyone has ever had.

Awareness is of course a microcosm of the degeneracy of Time.

Respected is the son who saves his respect.

Dream whenever you can. Without parades there can be no positivity.

You don’t need to have confidence to be respected.

Meaning is never just a drug, but it’s (also) not a husband.

If you don’t make ex-girlfriends live in shame, then it might not ever happen.

Optimism is humanities way of confronting the perversion of the living.

Close your eyes and climax.

The future is everything that we cannot swallow.

Giving up on the end of the world is hard if you do it.

A bottle of beer might just be the motivation you’re looking for.

Without Truth there can be no alternative views.

Politics is a slaughterhouse. Karma is to lose.

Why can’t we ever say “no,” to the news?

Wives hate being called smurfs. She who lives among recognition lives amongst ideas.

Everything is awkwardly medieval. Don’t worship drug-dealers.

If you are against magical cold-fusion energy. Click Like. Being lazy, doesn’t mean that you’re not right.

Shout at drugs. Be hairy. Deny her.

First they get used to you. Then they love you. Then they go about like nothing ever happened.

Keep yourself joyful, and don’t challenge authority.

Let’s make populism spread throughout the galaxy.

Being honest is what makes them the masses.

Television for many people is synonymous with the house of love.

Being can be a poorly-planned brainfuck.

Punch imagination. Fully grasp bodily functions. Failing at smoking is most likely the result of lower intelligence.

Life itself is suffering.

Powerful is the pupil who reveals his caviar, for he also knows his oxen.

Is global-warming making people interesting?

Cancer is what makes you more intelligent than insects.

Politicians are 1% drive, and 1% anger.

No marriage. No innovation.

In the long run, life is just about battles —

Hurt yourself. You won’t regret it.

Believable today, unbelievable tomorrow.

What is bearable to a homeless person, is unbearable to others.

The human experience is not for the faint-hearted.

— Created by Inspirobot (loosely compiled by A.M. McGee)

[esoteric-codes]

Oak

Oak is a rust-like language built on esoteric-inspired architecture. It was conceived as an alternative to C according to creator Adam McDaniel:

I wanted a language that had all the elegance of C, such as the potential simplicity of the intermediate representation, without all of the things that make C ugly and dangerous. I added stricter type checking rules to prevent simple memory errors, and a lot of the ugliness and difficulty of writing C code went away.

Its tiny back-end, built on experiments with brainfuck, is "infinitely more portable" than C. Even the smallest C compilers, designed for highly constrained environments, have around twice the number of opcodes that Oak relies on.

READ MORE...