# Racket

Racket is a programming language and language-oriented programming platform with macros for creating domain-specific languages.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Making OpenAPI / Swagger Bearable With Your Own DSL

DevFeed: [Making OpenAPI / Swagger Bearable With Your Own DSL](<https://devfeed.tech/articles/making-openapi-swagger-bearable-with-your-own-dsl-15757.md>)

Original publisher: [Read original article](<https://developer.squareup.com/blog/making-openapi-swagger-bearable-with-your-own-dsl>)

Author: Sebastien Armand

Published: 2019-08-02T19:00:00Z

Content type: tutorial

Language: en

Sources: [Square Corner Blog RSS Feed](<https://devfeed.tech/sources/square-corner-blog-rss-feed.md>)

Topics: [OpenAPI Specification](<https://devfeed.tech/topics/openapi.md>), [Racket](<https://devfeed.tech/topics/racket.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [domain-specific-language](<https://devfeed.tech/tags/domain-specific-language.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [json](<https://devfeed.tech/tags/json.md>), [openapi](<https://devfeed.tech/tags/openapi.md>), [swagger](<https://devfeed.tech/tags/swagger.md>), [yaml](<https://devfeed.tech/tags/yaml.md>)

### AI overview

The article explains how to use Racket to create a domain-specific language for defining OpenAPI documents. It addresses the verbosity, limited composability, and multi-file maintenance problems of handwritten OpenAPI, describing a DSL that produces YAML or JSON and reduced specification files from about 1,000 lines to about 100.

### Source excerpt

Taming OpenAPI using Racket to create a DSL

## Why Small Programming Languages Can Encourage Implementations Instead of Use

DevFeed: [Why Small Programming Languages Can Encourage Implementations Instead of Use](<https://devfeed.tech/articles/the-siren-song-of-little-languages-22023.md>)

Original publisher: [Read original article](<http://www.wilfred.me.uk/blog/2019/03/24/the-siren-song-of-little-languages/>)

Author: Wilfred Hughes

Published: 2019-03-24T00:00:00Z

Content type: opinion

Language: en

Sources: [Wilfred Hughes](<https://devfeed.tech/sources/wilfred-hughes.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Esolang](<https://devfeed.tech/topics/esolang.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [Racket](<https://devfeed.tech/topics/racket.md>)

Tags: [clojure](<https://devfeed.tech/tags/clojure.md>), [languages](<https://devfeed.tech/tags/languages.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>)

### AI overview

This commentary examines how small, elegant programming-language specifications can encourage developers to build implementations rather than use the language. It discusses BF, Scheme, Shen, Forth, Clojure, and Racket, and argues that language designers should consider the risk while recognizing that multiple implementations can also indicate language health.

### Source excerpt

Some programming languages languish due to obscurity. They lack breathless blog posts exclaiming how much nicer they are to use. Other languages are too ambitious. They aspire to support so many features that the original implementers struggle to get a first version working. For example, the type system in Fortress required constraint solving which took exponential time. Sometimes a usable language struggles simply because it's too much fun to write your own. Developers end up building their own implementation rather than actually using the language. The most obvious implementation-focused language is BF. Despite having many implementations, BF programmers have to encourage the implementers to actually try using the language! Scheme is also susceptible to this. Wikipedia lists 31 different Scheme implementations, not to mention the many toy implementations. Writing a Scheme is a great introduction to interpreters, especially once you get beyond the minimal lisp featureset. I've certainly written more implementation code than Scheme code. The problem seems to be languages with a small, well written specification. Shen is a multiparadigm lisp defined in terms of an elegant base language with only 46 system functions. This has resulted in a remarkable 15 third-party implementations, but only a small number of libraries implemented in the language. This phenomenon is not limited to lisps. Forth is also a language that developers often prefer to implement rather than use. Jones Forth is both a Forth tutorial and a discussion of how to build a Forth compiler. There are even stories of people spending years working on implementations without learning much of the language. Designing a language with a straightforward implementation is not a bad thing. It's just a pitfall that language designers need to be aware of. Some crypto systems have this problem too. It seems that we need languages to be big enough that new users write hello world in the language, not write a tool for

## P vs. NP, A Primer (And a Proof Written in Racket)

DevFeed: [P vs. NP, A Primer (And a Proof Written in Racket)](<https://devfeed.tech/articles/p-vs-np-a-primer-and-a-proof-written-in-racket-40263.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2012/02/23/p-vs-np-a-primer-and-a-proof-written-in-racket/>)

Published: 2012-02-23T19:57:35Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Computing](<https://devfeed.tech/topics/computing.md>), [Algorithms, Complexity](<https://devfeed.tech/topics/algorithms-complexity.md>), [Racket](<https://devfeed.tech/topics/racket.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [big-o-notation](<https://devfeed.tech/tags/big-o-notation.md>), [class](<https://devfeed.tech/tags/class.md>), [computational-complexity](<https://devfeed.tech/tags/computational-complexity.md>), [computing](<https://devfeed.tech/tags/computing.md>), [decidability](<https://devfeed.tech/tags/decidability.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [fast](<https://devfeed.tech/tags/fast.md>), [halting-problem](<https://devfeed.tech/tags/halting-problem.md>), [input](<https://devfeed.tech/tags/input.md>), [language](<https://devfeed.tech/tags/language.md>), [machine](<https://devfeed.tech/tags/machine.md>), [np-completeness](<https://devfeed.tech/tags/np-completeness.md>), [p-versus-np](<https://devfeed.tech/tags/p-versus-np.md>), [primer](<https://devfeed.tech/tags/primer.md>), [racket](<https://devfeed.tech/tags/racket.md>), [solve](<https://devfeed.tech/tags/solve.md>), [theory](<https://devfeed.tech/tags/theory.md>), [turing-machine](<https://devfeed.tech/tags/turing-machine.md>), [turing-machines](<https://devfeed.tech/tags/turing-machines.md>)

### AI overview

A primer on the distinction between decidability and computational efficiency, introducing the complexity class P and its definition in terms of polynomial-time decision by a Turing machine. It also discusses efficient algorithms and gives a card-sorting example.

### Source excerpt

Decidability Versus Efficiency In the early days of computing theory, the important questions were primarily about decidability. What sorts of problems are beyond the power of a Turing machine to solve? As we saw in our last primer on Turing machines, the halting problem is such an example: it can never be solved a finite amount of time by a Turing machine. However, more recently (in the past half-century) the focus of computing theory has shifted away from possibility in favor of determining feasibility.

## A Taste of Racket

DevFeed: [A Taste of Racket](<https://devfeed.tech/articles/a-taste-of-racket-40242.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2011/10/02/a-taste-of-racket/>)

Published: 2011-10-02T22:42:57Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Racket](<https://devfeed.tech/topics/racket.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [introduction](<https://devfeed.tech/tags/introduction.md>), [languages](<https://devfeed.tech/tags/languages.md>), [programming](<https://devfeed.tech/tags/programming.md>), [racket](<https://devfeed.tech/tags/racket.md>)

### AI overview

An introduction to programming in Racket that explains functional programming concepts through lists, pairs, cons, quoting, and element access, with examples connected to Project Euler.

### Source excerpt

or, How I Learned to Love Functional Programming We recognize that not every reader has an appreciation for functional programming. Yet here on this blog, we've done most of our work in languages teeming with functional paradigms. It's time for us to take a stand and shout from the digital mountaintops, "I love functional programming!" In fact, functional programming was part of this author's inspiration for Math ∩ Programming. And so, to help the reader discover the joys of functional programming, we present an introduction to programming in Racket, with a focus on why functional programming is amazing, and a functional solution to a problem on Project Euler.

## Programming Primers--An Introduction

DevFeed: [Programming Primers--An Introduction](<https://devfeed.tech/articles/programming-primers-an-introduction-40236.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2011/08/06/programming-primers-an-introduction/>)

Published: 2011-08-06T20:15:07Z

Content type: opinion

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Java](<https://devfeed.tech/topics/java.md>), [Python](<https://devfeed.tech/topics/python.md>), [Racket](<https://devfeed.tech/topics/racket.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [introduction](<https://devfeed.tech/tags/introduction.md>), [java](<https://devfeed.tech/tags/java.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [python](<https://devfeed.tech/tags/python.md>), [racket](<https://devfeed.tech/tags/racket.md>)

### AI overview

This blog post introduces a planned series of programming primers for readers with little or no programming experience. It outlines coverage of general concepts such as data structures and functional programming, along with introductory tutorials for Mathematica, Java, Python, Racket, and possibly C or C++.

### Source excerpt

So far on this blog we've assumed familiarity with the programming languages used (at the time of this writing, this is Mathematica and Java). This is unfair for the mathematicians who have little to no programming experience, and we admit that some readers tend to skim those technical sections with source code. As our work on this blog progresses, we recognize that the mathematical elegance is sometimes inherently manifested within the code itself.