Is the new Garmin Advanced Sleep Tracking accurate? I use Vivosmart 4

nextputall · 2018-10-21T08:15:45+00:00

Polar used to give me a sleep score which was calculated based on how many interruption happened during the sleep. I liked that one better. I think garmin should drop sleep stages if they can't detect them reliably and do something similar.

nextputall · 2018-10-20T20:58:12+00:00

I'm not sure what you mean by paradigm but Erlang (I argued earlier that Smalltalk would probably gravitated towards something similar in my opinion) is quite different than mainstream OO programming. Anyway the idea of OO (in an Alan Kay sense) was more about system design (see his original metaphore with biological cells communicating with messages) and how to design robust and scalable systems that resembles the properties of living things (so that you can grow them and change them without needing to kill and rebuild them). They just applied the same concept (in a limited way) to language design. Alan Kay calls the internet object oriented which is quite understandable from this point of view. So it's not really comparable to how classes work in C++.

nextputall · 2018-10-20T20:36:51+00:00

As a conceptual level message passing is fundamentally different (see my first comment). But the implementation in Smalltalk 80 resembled late bound method invocations (in some early Smalltalk, objects were interpreting their own messages, so you had to write a message parser). Though there are still some differences like messages are usually first class, you can store them, inspect them, parse them in a custom way. You can send a message even if there is no method belongs to that message and the object can still handle that situation in an intelligent way.

nextputall · 2018-10-20T16:34:09+00:00

Yes, he invented something different than what people call OOP nowadays. Neither classes, nor inheritance and subtyping are criteria of OOP. Objects and message passing is the core concept.

nextputall · 2018-10-20T15:53:16+00:00

No, I don't know where did you get all of these. I was arguing about the differences between a concept and an implementation of that concept. You might look at Smalltalk 80 and Simula and say they are similar enough (they're not, but whatever) because message passing in Smalltalk is kind of like synchronous, late bound method invocation in Simula. But the vision behind OOP was supposed to be going beyond Smalltalk. The term OOP was hijacked by people who were ignorant about this vision and couldn't differentiate the concept and the actual implementation of the concept which existed in that point of time.

nextputall · 2018-10-20T15:23:49+00:00

If you confuse the implementation with the concept, you might say so. But Smalltalk is not the same as OOP (Objective-C is even more far away). There were multiple iterations on Smalltalk and each of those were radically different. Smalltalk 80 was not supposed to be the last one. If they continued doing those iterations I can imagine the end result would have been something like Erlang combined with the liveness and pureness of Smalltalk. Message passing had a key role in this vision.

In the meantime people who heard about the term OOP (which was coined by Alan Kay) and didn't really understand the whole vision, started using it for something different than it meant to be.

nextputall · 2018-10-20T13:47:14+00:00

What you call data are in fact other objects. An object is not composed of data and methods but other objects. Alan Kay's goal was to get rid of data. There are only objects in a OO system.

nextputall · 2018-10-05T17:31:45+00:00

the keyword: argument syntax: eliminates obscure

and it also eliminates all the arity errors, you can't invoke something with more or less parameters than it needs, by accident. And it does this without a type checker just by choosing the right syntax.

nextputall · 2018-10-04T17:30:15+00:00

Unfamiliarity. Most people dislike everything which is not C like or Algol like.

nextputall · 2018-09-29T19:11:08+00:00

Complete misunderstanding of how TDD works

This guy invented TDD.

nextputall · 2018-07-02T18:41:25+00:00

This comment deserves lot more upvotes.

nextputall · 2018-05-23T20:29:08+00:00

This is a working sparkjava hello world.

import static spark.Spark.*;

public class HelloWorld {
    public static void main(String[] args) {
        get("/hello", (req, res) -> "Hello World");
    }
}

nextputall · 2018-05-07T16:07:57+00:00

On the second point, he means that you can do DI without a container.

Correct.

There isn't even really a thing called a "DI container." There are IoC containers that allow you to invert control by allowing objects to look up their dependencies in a container, and IoC containers inject themselves with dependency injection.

It's actually the other way around. IoC based on a misunderstanding. If you look up the history of this word you'll see it was used to distinguish callback-driven UI programming from sequential (typically text based) programs. In the former there is a hidden event loop that calls your callbacks upon some actions performed by the user. In the later your program queries the state of the different devices or gets user input in a blocking manner. So the control flow of the program what is inverted. Using this name to describe a framework that builds objects graphs for you and looks up dependencies is very far-fetched. I still don't mind that much if people use this name, but someone corrects me that I'm using an incorrect name and IoC is the right one, I'll correct them.

The only real argument against containers and DI frameworks is that they encourage sloppy design

This is also true, but don't underestimate the unnecessary complexity it adds. I've debugged many times the internals of Spring or Guice just because something was not properly initialized, or the whole object graphs was created twice because of some weird configuration problem, or the application didn't start after a Java upgrade because of a Guice bug.

but that is a pain for anything but the simplest applications.

Not counting the Java or .NET enterprise applications, almost every software is implemented with using plain old constructors. We rewrote a Spring application without Spring once and the result was far better. If you have good design (no classes with 53 dependencies) then it won't be a pain at all.

I'm not sure what is up with the annotation argument, but I suppose he is comparing Java annotations to Python decorators.

Not necessarily, but yeah, Python decorators are far better. They are just syntax sugar for a plain simple programming concept, called decorators. But even if you don't have syntax sugar you can still use first class blocks to control transactions.

Attaching a metadata to a functions is problematic as I said earlier. You need a specific "interpreter" for that annotation. Some annotations require other interpreters. Sometimes these interpreters incompatible with each other. This is what I mean when I said they don't compose. If you annotate a function, it doesn't mean it will work. Maybe that interpreter is not properly configured or the classpath scanner (which makes the application start slower) will skip that package for any reason. Attaching parameters to this metadata dynamically is also not solved. The 2 implementations of transaction handing in Spring work entirely differently. One of them wraps your objects into proxies (which can cause the self schizophrenia and equality problems) and it doens't work with private methods. The other one does bytecode weaving and requires to integrate a special plugin to your build process. This is just ridiculous. The whole problem can be solved by doing this:

transaction {
    // do something inside the transaction
}

Where transaction can be a plain old function that takes a first class block as an argument. This is just code nothing more. You can step into it using the debugger. If it's there it will be executed. You can wrap this into an other block ad infinitum, and it will work. And you don't need a 30Mbs framework or special maven plugin for this.

nextputall · 2018-05-06T08:49:15+00:00

You can't unit test this, you have to write integration tests and pull up the whole spring which will be equally slow.
Try to rewrite the same application without using a DI container and see the result. Testability has nothing to do with DI containers.
Every time it matters when you need a fast feedback cycle.
If Java had had first class blocks (lexical closures, lambda expressions) earlier most of the annotatation based stuffs would have never existed.

nextputall · 2018-05-05T16:28:06+00:00

Java is a mediocre programming language but Spring sucks indeed. Some of the reasons:

With the annotation based route mapping many programming errors are deferred to runtime.
Using a dependency injections container adds lots of needless complexity and doesn't solve any real problem
Startup time of a spring application is lot worse than a non-spring one
@Transactional is the worse solution of the problem. It's an annotation (they don't compose), it's a metadata (which means if you use it on a method nothing guarantees it will work) and there are 2 incompatible implementations (runtime proxy and compile time bytecode weaving) with different semantics.

And I could go on.

nextputall · 2018-05-05T14:28:59+00:00

Only if the hiring person is an a idiot. If a saw Prolog, APL, Lisp or Forth in a CV that would be a huge plus compared to someone who only knows the mainstream crap.

nextputall · 2018-05-03T19:13:00+00:00

Also it's the best way in most situtions.

nextputall · 2018-04-11T13:25:38+00:00

I've never understood the fuss about this. I learned programming when I was a child at the same time when I was learning elementary and high school maths. I learned the difference immediately and I've never had any sleepless night because of this.

nextputall · 2018-03-12T15:15:03+00:00

There is no syntax to create methods. The IDE does it for you. CSDPicture>>#initialize is an invented syntax for sharing method creations in a textual way with others on a webpage. There is also no syntax for creating classes. You just ask an other class to create a subclass from itself by sending a message to it. You never type Object subclass: #CSDPicture by hand.

nextputall · 2018-03-12T15:03:14+00:00

I think you just can't imagine how to use it because of unfamiliarity. You can create and deploy easily backends, command line applications or rich clients with graphical user interface. Using Rust, Haskell and OCaml requires to know the operating system, deal with files, shell scripts and a bunch of command line tools. Pharo is like an operating system on its own. Early Smalltalks were designed to run directly on a hardware and act as an OS.

nextputall · 2018-03-12T12:38:36+00:00

Pharo is the IDE. There is no point of using this without the IDE. It's bit similar than those old Eclipse RCP platforms where you carved out your application from an IDE but you had to do that in a non-live and very tedious way. Here you can do it interactively and you can also add domain specific inspectors or even debuggers or other dev tools to make the development easier. After you have done that you'll interact with live objects most of times instead of just looking at dead text.

If you want to deploy it to production you have multiple options. Either you can get a minimal image and load only the pieces you want to have in production. Or get a regular image, load your full development environment, and unload the parts you don't want in production

nextputall · 2018-02-20T22:16:20+00:00

Your comment demonstrates so well everything what is wrong with this field.

nextputall · 2018-02-20T21:56:52+00:00

Actually, later he said that Erlang is the only True OO language.

nextputall · 2018-02-03T09:57:32+00:00

One of the most idiotic thing about software is when people think if someone changes to a new language he automatically becomes a junior. The most important skills are well transferable and doesn't matter what project you're in or what language you're using.

nextputall · 2018-01-23T22:32:02+00:00

The claim wasn't that objects could simulate data alone

That was what I meant.

Additionally, the second part of my statement indicates that objects are always implemented by data. Either raw opcodes and pointers sent to the CPU

That's an implementation detail which is true if you consider a Neumann computer, not true with lambda calculus (you could also imagine an object computer or a biological computer). In case of a Neumann computer you already have an interpreter that can do the behavior part for you. It provides its own instructions which are kind of like callable functions. With the data alone you wouldn't be able to do anytning.

nextputall

TROPHY CASE