kasbah

Looks neat, will give it a go. I think you may be in violation of the GPL for your vim plugin since you are creating a combined work but are not releasing the TabNine source code under GPLv3.

https://github.com/zxqfl/tabnine-vim/blob/master/COPYING.txt

In a similar vein, I am not on Gnome or KDE but have been using the basic kdeconnect functionality, such as sharing clipboard and transferring files, through kdeconnect-cli quite happily. It comes with the standard kdeconnect installation I believe.

http://manpages.org/kdeconnect-cli

I have started using https://www.i-dont-care-about-cookies.eu (along with uBlock Origin and Cookie AutoDelete) for this reason. It just gets rid of as many of those dialogues as possible, haven't seen one in a month.

Super cool, hadn't heard of this, trying it out right now. I have often thought about trying to do something like this for the AntennaPod pod-catcher. Do you have an ETA on your open source release?

https://github.com/AntennaPod/AntennaPod/

I'd be interested in looking at co-developing something. I have been kicking around ideas about using constraint programmning for electronics CAD in my head for quite a while which is why I found this blog post so fascinating. I began developing something I called Footwork [1] where you could write KiCad footprints in Racket, with the end goal of hooking this up to the Rosette constraint programming DSL, but I didn't get very far with it.

I know there are some experiments like fpmagic [2] and people drawing KiCad footprints in Freecad [3] (which I assume lets you draw using constraints). Like you said, there are proprietary commercial solutions as well but I rarely find the time to assess them.

After reading this blog post and looking at the author's libfive, I thought I would play around with that and see if I could start a solution using it. I'd be interested to hear what your own approach to this would be though.

[1]: https://github.com/monostable/footwork

[2]: http://fpmagic.engineerjs.com/

[3]: https://forum.kicad.info/t/import-create-footprint-dxf/11818...

Great news! For Kitspace [1] I am currently working on re-purposing GitLab for electronics projects. It's good to see that "upstream" is getting more financial support.

I believe GitLab being open source is going to save me a ton of time and it could do this in other areas as well. I always thought GitHub could have been a much more remarkable product if it had been open source given its community. Let's make it happen with GitLab.

[1]: https://kitspace.org

Etching doesn't have to be super messy if you are experienced in it and have all the equipment set up. I would also recommended using ammonium persulphate over ferric chloride as it's a see-through and a bit less nasty.

I few months ago I would have dismissed DIY PCBs altogether in a heartbeat. But I visited my friend who etches PCBs on the regular and as long as you are OK with the limitations there is a lot to be said for holding your design in your hand minutes after having layed it out. I wrote a bit about this experience in my blog: https://blog.monostable.co.uk/posts/etching-oscillators-in-z...

Maybe they are not interested in optimization for the sake of optimization? For my use case it has been plenty fast anyway (not that it's a particularly intensive use case).

I am reading up on this a bit and it seems very interesting but I am not quite sure it would be able to fill the gap that something like Antlr fills. We want to generate parsers in various languages (JS, Python, Go) from a single grammar and existing implementations of "Parsing with Derivatives" seem to be experimental and mostly in functional languages.

Prolog is really interesting too but how would it work in practice for our use case?

But if I'd like to support older browsers I am out of luck, no?

Yeah dvc94ch who wrote most of what's been done for v2 so far was suggesting Rust and then web-assembly. Kind of warming to it after using Antlr for a while. We both really need JS versions though so I am still not sold. Compiling with Emscripten might be an option but it could be a lot of pain as well.

I have thought about it since it should be pretty easy to do. Feel free to open an issue or make a PR.

I think once you are entering actual manufacturer part numbers you are better off deferring this to a parts database or search engine. In my uses I have been deferring this to an Octopart search. You can see this working on e.g. https://bom-builder.kitspace.org (enter something into the description field and click around on the wand icons).

We are planning to include standard part naming schemes such as Pro Electron [1] and JEDEC [2] to recognize common diodes and transistors where it makes sense. The more interesting approach to me is to actually try recognize transistor descriptions such as "npn sot23 125mW beta=200 ic>=200mA". There is some work in progress, by dvc94ch, for both approaches (if I recall correctly) on the antlr branch: https://github.com/monostable/electro-grammar/pull/4

[1]: https://en.wikipedia.org/wiki/Pro_Electron [2]: https://en.wikipedia.org/wiki/JEDEC

Hey folks, I created this to augment the Octopart API while working on bill of materials tools for https://kitspace.org.

Working with Nearley was a fun experience and I recommend the blog post that got me started with it to anyone who is interested in writing a parser in JS: https://medium.com/@gajus/parsing-absolutely-anything-in-jav...

We have started porting it to Antlr to make it language agnostic though we are still open to looking at other options as well. Does anyone have any good experience or some ideas for alternative approaches?

`await` is useful since with the absence of it you can schedule multiple tasks concurrently. In JS:

    var task1 = someAsyncTask1()
    var task2 = someAsyncTask2()
 
    await Promise.all([task1, task2])

If `await` was implicit then task2 would wait for task1 to finish.

Currently evaluating using GraphQL. I have used it for a smaller endpoint [0]. I like the server side as I feel it lets me express the purpose of the API really well.

I have been using straight HTTP requests to query the GraphQL endpoint. Now, wanting to do something more complex, I am disappointed in the state of GraphQL clients. Everyone says use Apollo but it has some serious issues (e.g. caching [1]). Relay seems over-kill/restrictive and none of the other alternatives seem complete. I feel like maybe my life will be a bit easier if I just stick with REST especially since I am proxying an exiting API.

[0]: https://github.com/monostable/kitspace-partinfo

[1]: https://github.com/apollographql/apollo-client/issues/3452

Your RSS feed doesn't seem to work with https://github.com/AntennaPod/AntennaPod/

It doesn't trigger the usual RSS subscription offer on Firefox either. Are you sure it's formatted correctly?

While I listen to Functional Geekery on the regular and do enjoy it, I would say Proctor has great guests but the interviewing style definitely has some room for improvement. The thing that comes to mind is explaining for every guest "and... I became aware of you through <some mundane details>" but there is a lot more to what makes me feel the interviews are a bit lacking in energy sometimes.

This one with Mathias Felleisen is an old interview from 2016 by the way, not sure why it's popping up here now.

I did say "unless you use a break". I don't think this is very useful.

Seems a bit useless since

    while x < 2:
        ...
    else: 
        print('>= 2')

is the same as

    while x < 2:
        ... 
    print('>= 2')

unless you use a break. Just seems unnecessarily confusing to me. I have used for ... else though.

Surely `await f()` should be a type error if `f` doesn't return a future and checking for that seems useful. I am not up to speed on Python's types but in most type systems you can do something like `f : Future<Int>` which _will_ tell you what the future will eventually yield an `Int`.

Thanks, I'll try and keep an eye out for that.

EDIT: There is a smaller thing I noticed: a function on its own is a syntax error in GNU APL (and they can't be assigned to variables either).

An emacs mode for what? I don't use emacs much but would be up for using it it helps me with something. Fairly happily plodding along with just the GNU APL interpreter and akt though (and akt seems to work with vim through invoking `akt vim`).

Thanks for the link. Do you know if there is something similar for GNU APL?

Do you think it will be annoying to switch to GNU APL after going through this? I'd rather not spend time learning a proprietary interpreter if there's a viable free software alternative.

EDIT: Have started going through the tutorial using the GNU APL interpreter. I'll see how it goes I guess. 2+5 seems to work the same :)

EDIT 2: akt makes it possible to type the symbols without a special keyboard with GNU APL https://github.com/TieDyedDevil/akt

I think what you are asking is about just learning basic electronics and the digital protocols that connect different "modules" (and what kind of extra circuitry they need). For most consumer stuff (i.e. if you are not working on cars or industrial robots) you can get a lot done with just knowing about these three protocols:

- UART: https://en.wikipedia.org/wiki/Uart

- SPI: https://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bu...

- I2C (sometimes called TWI - two wire interface): https://en.wikipedia.org/wiki/I%C2%B2C

For more links for learning electronics check out my list of resources: https://github.com/monostable/awesome-electronics.

You might want to check out the Eclipse Layout Kernel. I don't know if it supports everything you listed but it does seem to make for some neater graphs.

https://www.eclipse.org/elk

Bit late to the party, a lot of great answers already and I can't add much more but this list of resources I maintain will probably be useful to you, especially the learning and video section.

https://github.com/monostable/awesome-electronics

Are you quoting something or is this your own mini code of conduct?

No, there is a question on a grant application form to link to the code of conduct if there is one. _Mild_ pressure to have one I should have said maybe.

I feel like that would just be avoiding the issue (burying my head in the sand, so to speak).