thinxer

For “cloud-native” apps, JuiceFS is not needed.

S3 is not designed for intensive metadata operations, like listing, renaming etc. For these operations, you will need a somewhat POSIX-complaint system. For example, if you want to train on ImageNet dataset, the “canonical” way [1] is to extract the images and organize them into folders, class by class. The whole dataset is discovered by directory listing. This where JuiceFS shines.

Of course, if the dataset is really massive, you will mostly end-up with in-house solutions.

[1]: https://github.com/pytorch/examples/blob/main/imagenet/extra...

For context:

1. https://twitter.com/rus/status/1641908582814830592

2. https://twitter.com/bighuman/status/1641910129384648706

On the first sight I fired up Developer Tools to check the banner is *not* <marquee>.

I expect Photoshop to contain many highly optimized function routines for photo processing. These routines are optimized by hand and usually use architecture-specific features such as SSE/AVX which is not portable.

Unoptimized (more portable) versions of theses routines exists, but I suspect they will perform well even with M1.

This looks like Entity-Component-System[1] in game development. Entities are composed of components, and components are often stored vectorized.

[1]: https://en.wikipedia.org/wiki/Entity_component_system

It is because Google wants a monorepo, then Google choose to use Perforce (and later Piper). It is not that Google uses Perforce and thus are limited to a monorepo.

The core value behind monorepo (and monorepo-like approaches) explained in the book is that dependency management is harder than version control.

For anyone interested in why monorepo works, I'd recommend the book Software Engineering at Google: Lessons Learned from Programming Over Time. It has detailed the reasons for the One Version Rule and Version Control over Dependency Management.

I'm using this: https://github.com/uxbh/ztdns.

The site is using Let's Encrypt for https. Currently there is a hard limit of 2000 subdomains per week, meaning there will be at most 2000 simultaneous connections!

It seems that Wildcard support is coming Jan 2018.

Some basic analysis:

1. Kernels (Functions in NNabla) are mostly implemented in Eigen.

2. Network Forward is implemented as sequential run of functions. No multi-threaded scheduling. No multi-GPU or distributed support.

3. Python binding is implemented in Cython.

4. Have some basic dynamic graph support: run functions as soon as you add them to the graph, and run backward afterwards. Somewhat similar to PyTorch.

5. No support for checkpointing and graph serialization, or I'm missing something.

I'm not sure why Sony is releasing this (yet another) deep learning framework. I don't see any new problems the project is trying to solve, compared to other frameworks like TensorFlow and PyTorch. The code is simple and clear, but nowadays people need high-performance, distributed, production-ready frameworks, not another toy-ish framework. Someone please shed some light on me?

BTW, for newcomers to deep learning systems, [CSE 599G1](http://dlsys.cs.washington.edu/) is a good start.

Is rootless containers safe now? It is not turned on by default in ArchLinux because of security concerns[1].

[1]: https://bugs.archlinux.org/task/36969

I don't see the point of writing a machine learning package in Go.

Go is designed for system programming, which is the opposite of scripting. In scientific computing, interactivity is an important feature. Softwares like MATLAB and IPython(now Jupyter) become popular because of this. Go doesn't have a nice REPL like IPython, and it never will. Besides, Go doesn't allow operator overload, which leads to verbose programs. Compare `c = a @ b` with `c := Must(Mul(a, b))`, the former Python statement is much cleaner than the Go one.

Usually, researchers use MATLAB, R, and Python for prototyping and training. The final model will be put into production by using something like TensorFlow Serving or by hand written C++ for performance. Even if the final product uses Go for serving, the Go program mostly runs the model via cgo or RPC.

Write in C/C++, and wrap the library in Python and Go is a much saner option. TensorFlow and MXNet are both good examples.

tl;dr Apple shipped curl without HTTP/2 support on their macOS, and the author of curl can do nothing about it.

How does this compares to gRPC which has many languages supported already?

Interesting but is this HTML+JS reinvented?

Previous discussion: https://news.ycombinator.com/item?id=11483934

I'd like to introduce htmlutil[1] and cascadia[2] for DOM processing in Go which is useful in scraping articles.

[1]: https://github.com/thinxer/go-htmlutil

[2]: https://github.com/andybalholm/cascadia

Python really need something like Go's official libraries. I mean those with a prefix "golang.org/x/". Those libraries update more often than stdlibs but still provide a concrete common ground for developers. It is like "evergreen" stdlibs.

The spec hasn't been updated for 8 months with several PR outstanding. What can be do to push the spec forward when the original leaders seem to be absence?

Here's the `grace` package from Facebook: https://github.com/facebookgo/grace

I tried this it's really really simple to set up (than openvpn tinc etc). However NAT traversing is still a hard problem and I cannot get online behind two NATs.

It seems to be solving the pain of not being able to share URL to 3rd party apps on iOS.

You could also use a global proxy, with a PAC filtering out those ads.

I'm not sure but will it be easier to build an interactive console especially for golearn? I believe the IPython system is a boost to Python's success on scientific computation.

Will Dropbox or Google Drive provide limited access to 3rd party apps so that they will have access to only limited folders in my account? I feel nervous when I have to give out my whole Dropbox to some web app.

yet they provide a rendered version for crawlers. try append "?_escaped_fragment_=" to the pages, like this one:

http://officialandroid.blogspot.com/2014/04/new-mobile-apps-...

And you will see the text content. It sucks, anyway.

I don't understand. How is Lua's performance compared to NodeJS, or compiled languages such as Java or Go ? Does it make sense to stuck everything into a (used to be ) reverse proxy server ?

Does "FTL" stands for "faster than light"?

If unbufferred, is there any difference with mutex?

how about sending a errChan along with the delta to the deltaChan and and error will be guaranteed to be replied to the correct sender?

What's new about this? A Trello clone on browser cookies?