# racket

Published articles for racket.

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: article

Language: en

Sources: [Square Corner](<https://devfeed.tech/sources/square-corner-blog-medium.md>)

Topics: [OpenAPI Specification](<https://devfeed.tech/topics/openapi.md>), [Swagger](<https://devfeed.tech/topics/swagger.md>), [Racket](<https://devfeed.tech/topics/racket.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>), [openapi](<https://devfeed.tech/tags/openapi.md>), [racket](<https://devfeed.tech/tags/racket.md>), [swagger](<https://devfeed.tech/tags/swagger.md>)

### AI overview

The article's Racket DSL, called Swaggy, makes OpenAPI specs shorter and easier to maintain by generating YAML or JSON from reusable functions and hash maps. In the example, a five-endpoint pet API takes 61 DSL lines versus nearly 400 lines of YAML. Functions encode common schema details, shared entity fields, standard error responses, and definitions reused across documents; optional named arguments add less common properties. The author says any language with suitable function arguments could support the approach, citing Python and Ruby. The DSL is tailored to the service's response and error formats, so the article recommends building one around your own API. The author reports that documentation stayed current and other teams could update it without hand-holding.

### 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-55197.md>)

Original publisher: [Read original article](<https://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>), [implementation](<https://devfeed.tech/topics/implementation.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [scheme](<https://devfeed.tech/topics/scheme.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [Racket](<https://devfeed.tech/topics/racket.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>)

Tags: [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [functions](<https://devfeed.tech/tags/functions.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>), [racket](<https://devfeed.tech/tags/racket.md>), [scheme](<https://devfeed.tech/tags/scheme.md>)

### AI overview

The article argues that very small, elegant programming languages can attract developers who build interpreters and compilers instead of using the language. It discusses Scheme, Shen, Forth, Clojure, and Racket, and suggests that languages need enough size and usability to develop a community of users before multiple implementations become valuable.

### 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](<https://devfeed.tech/topics/algorithms.md>), [computational complexity](<https://devfeed.tech/topics/computational-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.