-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathindex.xml
123 lines (102 loc) · 7.81 KB
/
index.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>Josh Bowden</title>
<link>https://jbowden.me/</link>
<description>Recent content on Josh Bowden</description>
<generator>Hugo -- gohugo.io</generator>
<language>en-us</language>
<lastBuildDate>Wed, 27 Jul 2016 21:20:11 +0000</lastBuildDate>
<atom:link href="https://jbowden.me/index.xml" rel="self" type="application/rss+xml" />
<item>
<title>On (Essentially) Coeffects</title>
<link>https://jbowden.me/posts/reddit/on-essentially-coeffects/</link>
<pubDate>Wed, 27 Jul 2016 21:20:11 +0000</pubDate>
<guid>https://jbowden.me/posts/reddit/on-essentially-coeffects/</guid>
<description>Snipped and backdated from a Reddit comment of mine.
That&rsquo;s an interesting way to put. It&rsquo;s almost like const correctness or checked exceptions (done right) for side-effects since you have to maintain purity with what you are calling or otherwise becoming impure.
there might need to be some sort of distinction between a class containing only pure functions and immutable fields, and one containing procedures and/or mutable fields</description>
</item>
<item>
<title>On CTFE</title>
<link>https://jbowden.me/posts/reddit/on-ctfe/</link>
<pubDate>Mon, 25 Jul 2016 02:40:49 +0000</pubDate>
<guid>https://jbowden.me/posts/reddit/on-ctfe/</guid>
<description>Snipped and backdated from a Reddit comment of mine.
The biggest win for compile-time features is eliminating the need for clunky, external build tools when you need to generate boilerplate code. (See F#&rsquo;s type providers)
Instead, you can write functions that run at compile-time to generate ASTs for you instead of mudging with text source code.
This feature in general is called compile-time function execution (CTFE).
Pros The common scenario is that you have a pre-existing schema you want to generate code from (e.</description>
</item>
<item>
<title>On Polymorphic Row Types</title>
<link>https://jbowden.me/posts/reddit/on-polymorphic-row-types/</link>
<pubDate>Wed, 13 Jul 2016 06:03:11 +0000</pubDate>
<guid>https://jbowden.me/posts/reddit/on-polymorphic-row-types/</guid>
<description>Snipped and backdated from a Reddit comment of mine.
There are a lot of interesting similarities here. I also found the original paper that the blog post was referencing: &ldquo;First-class labels for extensible rows&rdquo; with discussion on Lambda the Ultimate.
I didn&rsquo;t as prominently show it in the example, but my examples use structural typing and union and intersection types (examples from my other comments).
It seems to me that what I&rsquo;m suggesting effectively is the same as using row polymorphism as shown in the blog post.</description>
</item>
<item>
<title>Using structural types with a lot of type inference</title>
<link>https://jbowden.me/posts/reddit/using-structural-types-with-a-lot-of-type-inference/</link>
<pubDate>Wed, 13 Jul 2016 02:40:38 +0000</pubDate>
<guid>https://jbowden.me/posts/reddit/using-structural-types-with-a-lot-of-type-inference/</guid>
<description>Snipped and backdated from a previous Reddit post of mine.
As /u/x-paste was suggesting in the [Official] Object Orientation Discussion thread about ad-hoc data structures, I still think you can get the niceness and flexibility of just throwing code togeather while still having strong typing.
That or have gradual typing to avoid the messy example I wrote for the otherwise simple eval() and can just use any like in TypeScript and don&rsquo;t bother with being extremely sound and specific.</description>
</item>
<item>
<title>On Mainstream FP</title>
<link>https://jbowden.me/posts/reddit/on-mainstream-fp/</link>
<pubDate>Fri, 08 Jul 2016 23:19:50 +0000</pubDate>
<guid>https://jbowden.me/posts/reddit/on-mainstream-fp/</guid>
<description>Snipped and backdated from a Reddit comment of mine.
If functional programming is so great, why is it still niche? We have a product that can practically eliminate runtime errors, make refactoring much easier, lighten the testing burden, all while being quite delightful to use. What’s the hold up?
One factor is that we make things artificially hard to learn, sometimes with a seemingly pathological glee.
This is from the Elm&rsquo;s &ldquo;Let Be Mainstream!</description>
</item>
<item>
<title>MUMPS Side Note</title>
<link>https://jbowden.me/posts/reddit/mumps-side-note/</link>
<pubDate>Thu, 07 Jul 2016 01:39:51 +0000</pubDate>
<guid>https://jbowden.me/posts/reddit/mumps-side-note/</guid>
<description>Snipped and backdated from a Reddit comment of mine.
Functional programming is fundamentally very simple, but we do a great job at over complicating things without providing the proper abstractions.
On a side note: as horrible as MUMPS is, I still think it&rsquo;s interesting having a key-value store built into the language.
Example from Wikipedia showing how to persist values to disk:
SET ^Car(&quot;Door&quot;,&quot;Color&quot;)=&quot;BLUE&quot; It&rsquo;s almost as if Redis was invented in the 90s and integrated into some horrible language.</description>
</item>
<item>
<title>“A Core Language with Extensible Language Libraries”</title>
<link>https://jbowden.me/posts/reddit/a-core-language-with-extensible-language-libraries/</link>
<pubDate>Sun, 03 Jul 2016 00:20:23 +0000</pubDate>
<guid>https://jbowden.me/posts/reddit/a-core-language-with-extensible-language-libraries/</guid>
<description>Click to view on seperate page&hellip;
/u/jaxrtech
True, the proposal is very abstract. To be a bit more concrete, here&rsquo;s what trying to create a hypothetical implementation might look like running down pipeline from the diagram:
Clients: Just about any IDE or editor has an API for code completion, rename refactoring, etc. Given your favorite editor, we would just need &gt;to write a shim for to talk over platform&rsquo;s protocol to interface the API.</description>
</item>
<item>
<title>[Reddit] Intersection Types</title>
<link>https://jbowden.me/posts/reddit/intersection-types/</link>
<pubDate>Thu, 30 Jun 2016 10:27:41 +0000</pubDate>
<guid>https://jbowden.me/posts/reddit/intersection-types/</guid>
<description>Snipped and backdated from a Reddit comment of mine.
Using intersection with primitive types not make any sense since there is no common type.
(In type theory, this is called the bottom type.)
Now, an example of where intersection types would actually be useful is with struct or record types that you can combine togeather (i.e. &ldquo;I want a type that has all properties in type A and all properties in type B&rdquo;.</description>
</item>
<item>
<title>Union Types</title>
<link>https://jbowden.me/posts/reddit/union-types/</link>
<pubDate>Thu, 30 Jun 2016 08:38:06 +0000</pubDate>
<guid>https://jbowden.me/posts/reddit/union-types/</guid>
<description>Snipped and backdated from a previous Reddit comment of mine.
Implementing union and intersection types could allow for interesting things. I know that at least Typescript and Ceylon implement them.
One major annoyance this alleviates is strongly typed collections with mixed types.
Now, this shouldn&rsquo;t be confused with regular algebraic data types (ADTs) a la Haskell or F#&rsquo;s &ldquo;discriminated unions&rdquo;, for example. ADTs kind of solve the problem but in a less powerful way.</description>
</item>
</channel>
</rss>