7 ms·

Wingman for Haskell

181 points by dunefox 5y ago

weatherlight 5y ago
Stuff like this make me wonder if we'll have jobs in 15 years.
- desine 5y ago
  At its heart stuff like this is no different than the jumps from punchcards you asm to c to python. You still need someone to solidify ideas into processes. The change is that the building blocks themselves become more complex.
  - k__ 5y ago
    If I look how much (dumb) code you have to write for stuff like UIs, I certainly hope such tools will automate that work away. Sure, it's easy money, but also boring, lol
- NateEag 5y ago
  I was worried about this for several years. I then had the realization that if someone manages to genuinely automate programming, humans will wind up still being in the loop to confirm that the generated code is reasonable under the hood, and to be sure we have people who understand what it's doing and why. If I'm right about that, code review chops will be worthwhile in the long haul.
  - Nevermark 5y ago
    I think the end game is humans just let self-coding machines work as long as they are generating more cash than the cost of resources they use. Otherwise ... DELETE! Or the machine runs out of the crypto it needs to purchase more computing capacity and halts naturally like Odin intended. Of course, there is just that existential risk that the machines recognizes the profit distributions we are taking are negatively impacting their margins - and ability to survive. :( Where all this goes, nobody knows! But it won't be boring.
- whateveracct 5y ago
  Wingman just automates sifting through what the Haskell types enforce - they restrict possibilities so much there aren't that many valid programs most of the time. There's plenty of Haskell programmers all the while tho ;)
- unhammer 5y ago
  For whatever automation a new tool gives you, you get new maintenance on that tool, other languages will want a tool that gives those features, systems running older versions will want upgrades in order to support the tool, 20% time will be spent on getting it running immaculately on Emacs, security researchers will find bugs in the tool so everyone has to fix, patch and upgrade, web sites for showing off the tool need designing and hosting, support forums have to be staffed, blogs have to be written, some novel use of the tool requires integration with various other systems, enterprise asks for a powerbi version that can integrate with oracle (it ends up being 5x slower, but does lead to more jobs in maintenance and meetings), more research is produced etc. etc.
runeks 5y ago
When can I get Wingman to fill in trivially simple holes, e.g. where the type of the hole is `TypeA -> TypeB` and there’s only one function in scope with that type? In this situation, choosing “Fill in hole”, Wingman always just fails with a “ran out of gas”-error. (Using GHC 8.10.7)
- dunefox 5y ago
  You could try to increase the setting for the search tree or restarting VS Code (at least that solved some issues for me).
dunefox 5y ago
I tried the example and it worked. I am indeed amazed, both at Wingman and how good Haskell and its tooling has become since I last looked at it a couple of years ago.
- whateveracct 5y ago
  One promise of Haskell is that, once you've become an advanced or expert user, it is a gigantic force multiplier for individual devs or small, tight teams. The way the tooling has progressed recently imo is that being proven in real-time.
  - bufo 5y ago
    What are your favorite new developments in tooling? I haven’t used Haskell since 2014.
    - whateveracct 5y ago
      For all the new tools (HLS, Wingman), it's the core tooling that has improved the most since the then. GHC (+ghci) and cabal are leagues ahead of 2014 now. Some other cool tooling advancements since then that come to mind are.. Nix integration (both nixpkgs and haskell.nix), ghc heapview, ghcjs, a glut of formatters, ghcid (is this that new?)
      - bufo 5y ago
        Thanks I'll take a look!
        whateveracct 5y ago
        Perusing GHC changelogs since then will show you a _lot_ of new things in the language, compiler, and repl for sure.
      - wyager 5y ago
        Ghcid rocks! Makes it super easy to develop in a terminal with no IDE. Just a text editor here and ghcid there, telling me instantly when I make a mistake.
thih9 5y ago
The download link leads to a github repository called “haskell-language-server”; how are these projects related? Edit: it’s addressed in the Wingman’s landing page FAQ. > Wingman is built on top of HLS, and that's the reason it doesn't require dedicated editor support. The project’s source code also lives in HLS, as a plugin: https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-tactics-plugin https://github.com/haskell/haskell-language-server/tree/mast...
- alisonkisk 5y ago
  A language server is an API for a program in a language, so that text editors and linter and code generators can all interact with the program without knowing about each other.
etaioinshrdlu 5y ago
I'll also mention that Codex / Copilot could help write Haskell code where I simply couldn't. Or, at least get me close. Generation with ML and then filtering with the typechecker/compiler for valid results could be a really powerful pair.
- plafl 5y ago
  I feel that there is some kind of link to duality in optimization. Like you are trying to bound the intended program from below and from above.
sourceless 5y ago
Fantastic. First time I saw something similar to this was Edwin Brady’s recent demo of Idris 2. It’s quite amazing just how much of a program can be machine-written when the types are strict enough. I hope holes & case-splitting get into many more languages.
- klysm 5y ago
  I want my sum types damnit. Nothing like writing a case match over a sum type instead of fighting inheritance.
  - carlmr 5y ago
    Yes, once I got to know sum-types with match destructuring in F#, every other programming language that doesn't have them feels inferior. It's just such a practical idiom.
miles 5y ago
Wingman is cool and all, but OmegaStar is really holding things up - still waiting on ISO timestamp support: https://www.youtube.com/watch?v=y8OnoxKotPQ https://www.youtube.com/watch?v=y8OnoxKotPQ https://www.youtube.com/watch?v=DYvhC_RdIwQ https://www.youtube.com/watch?v=DYvhC_RdIwQ Shout out to the Galactus team!
- stingraycharles 5y ago
  This comment and the relevancy of the videos make no sense to me. Am I the only one?
  - dunefox 5y ago
    It's because a microservice in the video is also called Wingman.
earleybird 5y ago
Nadia Polikarpova at UC San Diego is doing some interesting work in this space. Skipping to about 42:40 in the video Nadia discusses an evaluation with a range of skills using Hoogle+ and how the usage trends from concrete examples to mostly type level specification. https://www.youtube.com/watch?v=ZPyVcnCabIU https://www.youtube.com/watch?v=ZPyVcnCabIU
yakshaving_jgt 5y ago
If only it could do this… f :: YourTestInput -> CorrectAndPerformantAdventOfCodeSolution f = _ --- Seriously though, even after writing Haskell primarily for years, I've never done hole-driven development and I'm still not sure what I'm missing. I tried once — granted, that was a long time ago — but I didn't get it. This post[0] suggests I'm not alone in thinking this. I'm glad Wingman exists and I think branding it nicely like this is the right thing to do, but I think I need to see more concrete examples to really see the magic. Probably something like Gary Bernhardt's Destroy All Software screencast series. It's one thing for someone to tell you that vim is fast, but it's another thing entirely watching the tool come to life in the hands of an expert. I imagine it's a similar thing for Wingman — I still have this mental block where I'm picturing the tool conjuring up an undefined for each hole, which is exactly what the documentation suggests the tool doesn't do. I would love to see someone use Wingman to quickly hammer out an Advent of Code puzzle, or even something more real-world like an Esqueleto query (but is that even possible?) [0]: https://bitemyapp.com/blog/please-stop-using-typed-holes/ https://bitemyapp.com/blog/please-stop-using-typed-holes/
- sa1 5y ago
  The post talks more about usability issues rather than any theoretical issues. There are more fundamental objections to typed holes - but Wingman is kind of the answer to those concerns - with typed holes you're filling in types from the expressions, with Wingman you're doing pretty much the opposite - synthesizing programs from the type. Now there might be usability issues with Wingman as well, but it represents a different direction - more suitable for type-driven development.
danidiaz 5y ago
A video about Wingman with detailed examples https://www.youtube.com/watch?v=S0HvfXq3454 https://www.youtube.com/watch?v=S0HvfXq3454 including custom tactics https://www.youtube.com/watch?v=S0HvfXq3454&t=2139s https://www.youtube.com/watch?v=S0HvfXq3454&t=2139s
gnull 5y ago
Is the an out-of-the box way to use it in Kakoune right now?
eptcyka 5y ago
If one is able to write a tool to write your program for you, could it be the case that the language lacks syntactic constructs to be terse enough to be pragmatic?
- dan-robertson 5y ago
  Where is this comment coming from? That is, how much have you looked at what the tool does/written Haskell in the past? I think the key thing is that sometimes there are multiple ways to answer something. For example consider this type: [Maybe a] -> [a] It takes a list of optional values and returns non-optional values. The ‘obvious’ semantics in Haskell could be achieved with: f [] = [] f (Nothing:xs) = f xs f (Just x:xs) = x:f xs And there are plenty of other ways to write that function. But you could also write functions like g xs = [] h xs = reverse (f xs) j [Just a, Just b] = [b, a, b] j _ = [] And all three would satisfy the type above. So the type may be a sufficient input to the tool as the programmer may select the suggestion, but it wouldn’t be sufficient input to the compiler as the compiler could just guess the wrong thing.
  - deleted 5y ago
    [deleted]

Wingman for Haskell

181 points by dunefox 5y ago

weatherlight 5y ago

Stuff like this make me wonder if we'll have jobs in 15 years.

desine 5y ago
At its heart stuff like this is no different than the jumps from punchcards you asm to c to python. You still need someone to solidify ideas into processes. The change is that the building blocks themselves become more complex.
- k__ 5y ago
  If I look how much (dumb) code you have to write for stuff like UIs, I certainly hope such tools will automate that work away. Sure, it's easy money, but also boring, lol
NateEag 5y ago
I was worried about this for several years. I then had the realization that if someone manages to genuinely automate programming, humans will wind up still being in the loop to confirm that the generated code is reasonable under the hood, and to be sure we have people who understand what it's doing and why. If I'm right about that, code review chops will be worthwhile in the long haul.
- Nevermark 5y ago
  I think the end game is humans just let self-coding machines work as long as they are generating more cash than the cost of resources they use. Otherwise ... DELETE! Or the machine runs out of the crypto it needs to purchase more computing capacity and halts naturally like Odin intended. Of course, there is just that existential risk that the machines recognizes the profit distributions we are taking are negatively impacting their margins - and ability to survive. :( Where all this goes, nobody knows! But it won't be boring.
whateveracct 5y ago
Wingman just automates sifting through what the Haskell types enforce - they restrict possibilities so much there aren't that many valid programs most of the time. There's plenty of Haskell programmers all the while tho ;)
unhammer 5y ago
For whatever automation a new tool gives you, you get new maintenance on that tool, other languages will want a tool that gives those features, systems running older versions will want upgrades in order to support the tool, 20% time will be spent on getting it running immaculately on Emacs, security researchers will find bugs in the tool so everyone has to fix, patch and upgrade, web sites for showing off the tool need designing and hosting, support forums have to be staffed, blogs have to be written, some novel use of the tool requires integration with various other systems, enterprise asks for a powerbi version that can integrate with oracle (it ends up being 5x slower, but does lead to more jobs in maintenance and meetings), more research is produced etc. etc.

runeks 5y ago

When can I get Wingman to fill in trivially simple holes, e.g. where the type of the hole is `TypeA -> TypeB` and there’s only one function in scope with that type? In this situation, choosing “Fill in hole”, Wingman always just fails with a “ran out of gas”-error. (Using GHC 8.10.7)

dunefox 5y ago
You could try to increase the setting for the search tree or restarting VS Code (at least that solved some issues for me).

dunefox 5y ago

I tried the example and it worked. I am indeed amazed, both at Wingman and how good Haskell and its tooling has become since I last looked at it a couple of years ago.

whateveracct 5y ago
One promise of Haskell is that, once you've become an advanced or expert user, it is a gigantic force multiplier for individual devs or small, tight teams. The way the tooling has progressed recently imo is that being proven in real-time.
- bufo 5y ago
  What are your favorite new developments in tooling? I haven’t used Haskell since 2014.
  - whateveracct 5y ago
    For all the new tools (HLS, Wingman), it's the core tooling that has improved the most since the then. GHC (+ghci) and cabal are leagues ahead of 2014 now. Some other cool tooling advancements since then that come to mind are.. Nix integration (both nixpkgs and haskell.nix), ghc heapview, ghcjs, a glut of formatters, ghcid (is this that new?)
    - bufo 5y ago
      Thanks I'll take a look!
      - whateveracct 5y ago
        Perusing GHC changelogs since then will show you a _lot_ of new things in the language, compiler, and repl for sure.
    - wyager 5y ago
      Ghcid rocks! Makes it super easy to develop in a terminal with no IDE. Just a text editor here and ghcid there, telling me instantly when I make a mistake.

thih9 5y ago

The download link leads to a github repository called “haskell-language-server”; how are these projects related? Edit: it’s addressed in the Wingman’s landing page FAQ. > Wingman is built on top of HLS, and that's the reason it doesn't require dedicated editor support. The project’s source code also lives in HLS, as a plugin: https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-tactics-plugin https://github.com/haskell/haskell-language-server/tree/mast...

alisonkisk 5y ago
A language server is an API for a program in a language, so that text editors and linter and code generators can all interact with the program without knowing about each other.

etaioinshrdlu 5y ago

I'll also mention that Codex / Copilot could help write Haskell code where I simply couldn't. Or, at least get me close. Generation with ML and then filtering with the typechecker/compiler for valid results could be a really powerful pair.

plafl 5y ago
I feel that there is some kind of link to duality in optimization. Like you are trying to bound the intended program from below and from above.

sourceless 5y ago

Fantastic. First time I saw something similar to this was Edwin Brady’s recent demo of Idris 2. It’s quite amazing just how much of a program can be machine-written when the types are strict enough. I hope holes & case-splitting get into many more languages.

klysm 5y ago
I want my sum types damnit. Nothing like writing a case match over a sum type instead of fighting inheritance.
- carlmr 5y ago
  Yes, once I got to know sum-types with match destructuring in F#, every other programming language that doesn't have them feels inferior. It's just such a practical idiom.

miles 5y ago

Wingman is cool and all, but OmegaStar is really holding things up - still waiting on ISO timestamp support: https://www.youtube.com/watch?v=y8OnoxKotPQ https://www.youtube.com/watch?v=y8OnoxKotPQ https://www.youtube.com/watch?v=DYvhC_RdIwQ https://www.youtube.com/watch?v=DYvhC_RdIwQ Shout out to the Galactus team!

stingraycharles 5y ago
This comment and the relevancy of the videos make no sense to me. Am I the only one?
- dunefox 5y ago
  It's because a microservice in the video is also called Wingman.

earleybird 5y ago

Nadia Polikarpova at UC San Diego is doing some interesting work in this space. Skipping to about 42:40 in the video Nadia discusses an evaluation with a range of skills using Hoogle+ and how the usage trends from concrete examples to mostly type level specification. https://www.youtube.com/watch?v=ZPyVcnCabIU https://www.youtube.com/watch?v=ZPyVcnCabIU

yakshaving_jgt 5y ago

If only it could do this… f :: YourTestInput -> CorrectAndPerformantAdventOfCodeSolution f = _ --- Seriously though, even after writing Haskell primarily for years, I've never done hole-driven development and I'm still not sure what I'm missing. I tried once — granted, that was a long time ago — but I didn't get it. This post[0] suggests I'm not alone in thinking this. I'm glad Wingman exists and I think branding it nicely like this is the right thing to do, but I think I need to see more concrete examples to really see the magic. Probably something like Gary Bernhardt's Destroy All Software screencast series. It's one thing for someone to tell you that vim is fast, but it's another thing entirely watching the tool come to life in the hands of an expert. I imagine it's a similar thing for Wingman — I still have this mental block where I'm picturing the tool conjuring up an undefined for each hole, which is exactly what the documentation suggests the tool doesn't do. I would love to see someone use Wingman to quickly hammer out an Advent of Code puzzle, or even something more real-world like an Esqueleto query (but is that even possible?) [0]: https://bitemyapp.com/blog/please-stop-using-typed-holes/ https://bitemyapp.com/blog/please-stop-using-typed-holes/

sa1 5y ago
The post talks more about usability issues rather than any theoretical issues. There are more fundamental objections to typed holes - but Wingman is kind of the answer to those concerns - with typed holes you're filling in types from the expressions, with Wingman you're doing pretty much the opposite - synthesizing programs from the type. Now there might be usability issues with Wingman as well, but it represents a different direction - more suitable for type-driven development.

danidiaz 5y ago

A video about Wingman with detailed examples https://www.youtube.com/watch?v=S0HvfXq3454 https://www.youtube.com/watch?v=S0HvfXq3454 including custom tactics https://www.youtube.com/watch?v=S0HvfXq3454&t=2139s https://www.youtube.com/watch?v=S0HvfXq3454&t=2139s

gnull 5y ago

Is the an out-of-the box way to use it in Kakoune right now?

eptcyka 5y ago

If one is able to write a tool to write your program for you, could it be the case that the language lacks syntactic constructs to be terse enough to be pragmatic?

dan-robertson 5y ago
Where is this comment coming from? That is, how much have you looked at what the tool does/written Haskell in the past? I think the key thing is that sometimes there are multiple ways to answer something. For example consider this type: [Maybe a] -> [a] It takes a list of optional values and returns non-optional values. The ‘obvious’ semantics in Haskell could be achieved with: f [] = [] f (Nothing:xs) = f xs f (Just x:xs) = x:f xs And there are plenty of other ways to write that function. But you could also write functions like g xs = [] h xs = reverse (f xs) j [Just a, Just b] = [b, a, b] j _ = [] And all three would satisfy the type above. So the type may be a sufficient input to the tool as the programmer may select the suggestion, but it wouldn’t be sufficient input to the compiler as the compiler could just guess the wrong thing.
- deleted 5y ago
  [deleted]