tlack

If you are considering the purchase, I think it's a good deal. The API works well, as does the desktop app. Comes with a software-switchable air pump which is really handy too.

If anyone else is curious, here's the subreddit: https://www.reddit.com/r/remoteviewing/

The asteroid scale might be a bit much, but I think he's roughly saying any magnetic material that can be energized thats physically linked to the spinning shell.

This is way beyond my pay grade. :)

There are a lot of "mays" and "might be nice to's" in the document. But even the vibration element seems optional, going by my loose interpretation of the formula and contextual wording.

Has anyone tried building one of his simpler constructions?

https://patents.google.com/patent/US10135366B2/en

I've always loved programming and never had any doubts, though I don't particularly enjoy management. Maybe find the bits about programming or the biz in general that you love the most, and sorta blow that up into a full time gig in the next 2-3 years?

Pretty good intro to making a web server on these powerful, inexpensive ESP chips. Even handles mime types and stuff like that, which many others neglect.

I heard a rumor way back that they transported individual frames outside of WebRTC; if so, that saves them from having to tie in with that stack.

I really think it should be possible or even easy to write a WebRTC videoframes-only client, I just haven't had any luck. In fact, I've seen a few people saying they simply scripted Chrome with a <video> tag instead! That's madness.

I'm also looking for a fast depth or semantic segmentation model for use in my robotic arm end of arm. Let me know what you wind up using.

You could try running the model in the browser with Tensorflow.js. I recently tried this for something like that and found the overall workflow much easier. TFJS tooling is pretty good.

Before I had tried using custom setups with Janus in the loop and it was slow going. AioRTC flat out never worked for me.

Looks interesting and well produced.

I'm sending this to a few friends who are interested in coding to get a "real" take on it.

These guys provide their code in a very easily usable form. Anyone taking a crack at applying it?

Edit: Here's a full version of the paper:

Link to shared PDF: https://rdcu.be/b8sEo

Ramin Hasani's site, with a bunch of other related papers: http://www.raminhasani.com/publications/

Phoenix LiveView is definitely interesting but they didn't really have a framework in place to handle browser uploads until now. Seems like a pleasant and flexible API.

FPGAs are good at fast signal processing of diverse sorts.

Example in industry are are cable modems (en/decode wideband signal), set-top boxes (decode/decrypt media), precision optical equipment, hardware-assisted algorithms (compression, crypto), military, ...

Anything complex enough to require a CPU and some logic, but single-purpose and requiring high bandwidth.

Well, you'll need to understand the basics of things like pins, and how I/O works, and I'm sure some fundamentals. Perhaps a 1 month journey through Arduino too.

But FPGAs are programmed in a C-ish language called Verilog (or VHDL) which sort of insulates you from the specifics to some degree.

Given my current interests, I'd probably try to translate a machine learning model into a Verilog program or something along those lines. But that's a combination of two complex things.

Maybe a good first project would be "make a really fast webserver" by embedding a webserver + TCP/IP stack into an FPGA. Or a really fast compressed columnar database engine.

Good luck! t

Here are two rando ideas from an occasionally burned out fellow coder:

1. FPGAs. Get your software turned into sorta-hardware. Very fast, and now, very cheap.

2. Reinforcement learning. Teaching a machine to optimally play a game - any game. Very complex rabbit hole, but surprisingly easy to dip your toe in. See my previous comment: https://news.ycombinator.com/item?id=24693277

I've been playing with reinforcement learning on simulated robots, using OpenAI Gym[0] and PyBullet[1].

I find it interesting because, in theory, the learned policies transfer to real-world robots, and the time is nigh for development in that area. Plus you get to watch it do funky robot shit and slowly get better.

If you want a quick way to dive in, I have a repo[2] I've been using to train on a variety of PCs and Google Colab[3]. The task is a Panda robot pushing a randomly placed object. I had some trouble getting it all working with recent Keras at first, so my repo might save you time.

Email me[4] if you get stuck.

[0] https://gym.openai.com/

[1] https://pybullet.org/

[2] https://github.com/tlack/rl-experiments

[3] https://colab.research.google.com/drive/1HGmKMGwW_emok157ENr...

[4] lackner@gmail.com

Pretty good!

I knew most of that stuff already so I can't speak to the pure education value, but it made sense, and I think you hit the key points.

I bet some visuals would help it make sense for total nooberz.

AND! I didn't know that about "v" - thanks! :)

What you said is rarely stated in public, but I've often felt it too: OTP obscures the underlying beauty of the Erlang platform.

OTP is well engineered of course, but the basic notion of the spawn -> receive -> loop cycle is so clean and illuminating that I wish newbies would hold out before learning OTP sometimes.

It's natural to think of case-specific abstractions around the primitives that are more germane to the domain at hand than OTP's.

Oh definitely true. And they have done a killer job of building out all the bells and whistles and making it all quite fast.

But as someone interested in the guts, or understanding how to implement new types of systems, it can be quite overwhelming!

I'm disappointed he isn't releasing the source for these or LibNC. We definitely need non-academic, non-Python machine learning implementations. Anyone know what's up with that?

I've had some good luck with "Unfluff"[0], a credible Node.js package that uses a cascade of logical conditions to figure out what to extract.

It's a very practical start.

I thought the science of it was called "envelope detection" but I'm not getting any relevant hits on that keyword. Will report back if I recall the name.

[0] https://www.npmjs.com/package/unfluff

Some protocols have so much persistence, where others seem to be tied to one vendor's fate.

I wonder if its worth spending some time trying to understand what makes some protocols so robust and widely adopted. It's not just being open vs closed.

A few other examples:

  - PostScript (probably) / PDF (iffy)
  - CAN (adaptable)
  - G-code
  - Serial
  - HTTP
  - HTML (sort of, badly)
  - VNC (maybe)
  - JSON (for now)

My take as a hobbyist in this area:

In highly complex, long running systems, it's very difficult to know automatically when memory is no longer needed.

Reference counting, and its draconian creepy uncle malloc()/free(), require programmers to be very careful about when they free memory.

This is a life of tossing in turning in bed: Did you carefully free before you returned in that error handler?

C++ has the benefit of strict compile time analysis, and a lot of the confusing bits have sensibly been pushed to the standard container types' implementations.

Dynamic systems with diverse "types" and millions of collections of objects, especially ones that are likely to contain "cycles" and references to each other, often take other approaches that aren't as "match up the alloc() and free()"-oriented, such as periodically scanning the entire object graph and deleting stuff that couldn't be reached.

Madness! But runs like hell when the graph is small and most people won't feel the burn. An ongoing area of research.

"We" didn't entrust him. The users -- those blind, piteous, sorrowful, clearly-very-bored people -- trust him.

What's the use of worrying about him, or them? Just quit the site!

p.s. also hi Brian! chance encounter..

You feed in Rust (a flavor called DSLX) or C++ and it generates code for your FPGA (in Verilog). You then upload this compiled "bitstream" to your FPGA and now you have something akin to a custom microprocessor, but running just your program.

Burn the book and collect data from the bonfire.

Everyone is different. Just expand your mind regarding things that interest you. Your mind is like "ehhh I don't enjoy this material". Which is fine. It's dry af.

Get really deep in something coding related you do love, and can 2x or 3x your income with, and come back to TaoCP.

APT is an Advanced Persistent Threat, or more casually known as a good hacking group. :)

Does it have to be GUI software?

If not, Q/Kdb[1] redefined my notion of "economy" in the sense of resource usage. The whole environment with about 60% of what you'd expect is like 500kb?

It's also very very fast, processing millions of records a second. It changes the way you iterate on things when you can get results back instantly.

This is one of the few software packages I've used in the last couple years that stunned me with speed. Most people are too lazy to care.

Q/Kdb is far from perfect, but you didn't ask for perfect. :)

[1] https://kx.com/

This language has some interesting properties. Here's a code example featuring a user-defined event that triggers a handler. This kind of callback-oriented indirect application at the language level would be nice for async programs.

  from @std/app import start, print, exit
  event loop: int64
  on loop fn looper(val: int64) {
    print(val)
    if val >= 10 {
      emit exit 0
    } else {
      emit loop val + 1
    }
  }
  on start {
    emit loop 0
  }

Code sample:

Actor model with explicit synchronicity and access scoping:

  actor Counter {
    var value = 0;
    public func inc() : async Nat {
      value += 1;
      return value;
    };
  }

Types and specificity:

  type Tree<T> = {
    #leaf : T;
    #branch : {left : Tree<T>; right : Tree<T>};
  };

  func iterTree<T>(tree : Tree<T>, f : T -> ()) {
    switch (tree) {
      case (#leaf(x)) { f(x) };
      case (#branch{left; right}) {
        iterTree<T>(left, f);
        iterTree<T>(right, f);
      };
    }
  }

Source: https://sdk.dfinity.org/docs/language-guide/motoko.html

Not to my taste personally.

It all depends on the nature of your application. A video editor and a command line utility are so different!

Sounds like you already know the big players so I won't repeat them. Instead, here are some off-kilter ideas:

1. Casual use, general interest, notification-requiring, simple single-file data requirements, tolerant of desktop / mobile split sessions? Try making a chat bot for Telegram, FB, Discord, Slack..

2. Dynamic, visualization-focused UI with simple options that need to be tweaked interactively? Try Imgui[0] or Godot[1]

3. Scientific or data-centric stuff pulling in data from here and there, but meant for interactive exploration? Try Wolfram / Mathematica or an IPython notebook / GoogleColab

[0] https://github.com/ocornut/imgui/wiki/Software-using-dear-im...

[1] https://medium.com/swlh/what-makes-godot-engine-great-for-ad...