I buy ebooks, and then buy paper copy if I really like the book.

Unit testing is important because it describes how a function or class should work. Outside participants to the project could first look at the test, and from observability perspective determine what it's supposed to do.

Unless you can go through the rigorous exercise of proving out that your code works with linear logic, it's hard for someone to claim that something will work out of box when they ship it.

Test coverage as a number means nothing, that I agree, and often programmers don't know the difference between unit tests and integration tests. Often unit tests are not valuable when the developer writes something that isn't really testing the functionality from input output perspective. Side effects are hard to test when dependencies increase for a given unit.

LOC isn't the objective for writing code. Source isn't made any more complex by adding unit tests - if it is, then the programmer is doing something wrong by injecting test specific stuff into prod code.

Reusability isn't the principal claim that unit test advocates are making. The claim is that extensive tests reduce two things:

1. Incorrect assumptions about the code itself
2. Regression errors due to new feature deployment

Different point being made here is about what constitutes elegance, and that is outside of the scope of debate about unit tests.

Nim is really nifty. For those who aren't familiar, Nim is a systems development language, much in the same way Go is intended to be. Nim isn't trying to solve the same class of problems that Rust is trying to solve. Basically if you have any experience with trying to develop something like a webapp or a backend application in c, you'll realize that you can get mired in re-implementing a lot of stuff.

What's Nim for? First of all it has concurrent programming support built into standard api. Think of how Go makes concurrent programming easier to approach. Nim is similar in that sense.

Garbage Collector? Nim has a garbage collector. That alone is a turn off for a lot of people gathering around Rust. But use of garbage collector is optional for Nim.

Compiling to c? Nim dev team has a long term plans for compiling directly into binary. I think compiling to c is a good first step, and it allows no-nonsense portable development.

One thing I don't like about is the syntax, it seems like it's heavily influenced by Python. Other than that, there is a lot to like about the language.

You know the funny thing is that I've been posting mostly useful stuff, and each of those posts has been downvoted exactly twice.

Also, waiting for that obligatory 2 downvotes. :)

Hmm weird, it's definitely programming related, yet downvoted.

BURN IT ALL DOWN

Policheck lol, can't make this stuff up.

This post has nothing to do with programming... Can we at least try to stay on topic? Maybe this is better served under /v/technology ?

Typical. Gives you 24 hours and just merges it. Not even github was this asinine.

If I remember correctly this was the time when StrongLoop was on the fence about whether to back IO.js or not. Eventually StrongLoop decided enough was enough (with Joyent calling Ben to be fired, the guy who wrote 28% of libuv, over a pronoun)

I'm glad Joyent got their asses whooped and had to submit to Node.js Foundation deal. Fuck them.

Having programmed Node.js applications for cloud, Node.js addons for another application, and just plain old POSIX C programs for embedded devices, I can tell you that Node.js does a lot of things right, and I have so much more appreciation for standard API that Node.js provides now that I've coded in C and had to re-implement some of those functionalities.

Node.js does allow a lot of higher level abstractions to be installed and used relatively painlessly, and the accolades it get isn't just from the HR people - originally they are from the frustrated devs who switched to Node.js and found out that it's super effective at going from 0 to 1.

HR people eventually saw the productivity and figured, if Joe Hacker can pump out functional code with Node.js, why not every Tom, Dick, and Harry? That's why it's now over-hyped.

So, please don't be too hard on Node.js. It's not the framework that's bad, it's the un-enlightened people who think Node.js is the panacea for all development woes.

Is the data something that can be put into a table?

If so, have you looked into columnar database called fastbit?

It uses bitmap indexing and word-aligned hybrid compression to have a good space-performance trade-off.

There's some hope yet!

Besides that, I don't want to live in the community where a member can possibly be casted out forcefully. It's not nice. It should be resolved by law enforcement, if needed. Thus banning is out of question (for me at least).

Matz.

Good bye Ruby.

• Don't contribute to FOSS projects with CoC.
• Self-host your own repo.
• Brush and floss your teeth.

Yep. Right after this he goes on to say that.

Yes it does.

I don't think they were blaming glibc. They were telling you about java because that's how they found out about this. Anything that uses glibc (like hadoop) is affected by it and can be really annoying. This is usually benign, except when programmers try to use the knobs given and those knobs are undocumented (M_ARENA_MAX for one isn't even in the man page for mallopt)

Excessive virtual memory allocation can be a problem because the allocated memory (which is really virtual address space, so should be relatively safe) can cause application to quit out if there are any ulimit() or setrlimit() kind of things within the process in question.

Multithreaded applications in particular are heavily affected by this, and can cause heartaches if the programmer using glibc >= 2.10 isn't aware of it.

Here's a background info for those interested: https://sourceware.org/bugzilla/show_bug.cgi?id=11261

Beware.

He goes over it in the latter half of the article. He mentions first one to come up with a working prototype for a given project should be the crown, because he is most intimately aware of the architecture and the initial implementation difficulties.

Also N different kingdom isn't the right analogy. The article states vassals who chose to be part of the project and owns a smaller piece of the overall project. If there is enough contention (primarily due to poor organization forms like undemocratic socialism), the article suggests, that there will be fundamental schism and malcontent participants either 1) form their own project 2) continue to disrupt the project with unproductive squabble.

The proponent of the Sovereign Software Development model tells us that successful software development projects all follow this natural order.

Personally I think bryanedds is right. Linux core development is a great example of what is being described.

Just understand that the SSL certificate is for 3 months. Make sure you have cronjob that run it every two months or so.

For what it's worth, I use char *p since it seems to make more sense to me personally.

Article title says "Programming Languages"

I am commenting on the "best case" scenario diagram at the bottom, where the author suggests that if you have +20 years experience with C++, and you work in US, you can get "princely" salary of $95000. Author doesn't seem to realize that there is a fierce competition for talent, and someone with +20 years experience would command a lot higher salary.

In other words... try $160-180k.

Sorry gophers, your language is being taken over by zealots.

Also, if you tried to recruit C++ expert with 20+ years of experience and try to offer them $95000 they will spit on your face.

AWS is not a language.

I hope he gets a job in Apple so he can come over to US. ;_;

Plus, the dev for Gitblit sounds like he knows what he's doing. GitMinute interview with GitBlit dev, James Moger

It's not. It's just a way to schedule an application to run at a specific time from a linux service (background process) called cron. Useful when you don't want a thing to run constantly, but just want a batch job to be done. For an example, running a shell script that collects and puts some log files together into a folder at 7 am in the morning or something like that.

Yep. I moved away and I am now self-hosting.

Here are some that I got just in last year:

1. Make a relationship graph similar to LinkedIn. Write a code to get how close person B is to person A from that graph. (15 min to half hour) Follow up: What are some of the things you should worry about when traversing?

2. You have a large logs of different events. Given that it has a column of time, IP address, description, and event type, write a code that checks for three sequential events from a same IP address. (15 min to half hour) Follow up: How would you improve the logging system to allow for easier classification of "sequential events?"

3. Given a set of substitution cipher text, write a code to decrypt it in language of your choice. (Gives you an hour to do this with a laptop)

4. For an April Fools joke, you are to design and code a password login front-end that takes in a password that is case insensitive and lets users login for a case sensitive user password. Assume there is no API call limit for login. (One hour, white board)

Generally I noticed a lot of recent interview questions that I got is regarding graph and tree traversal. There are some recursion questions as well.

Code of conduct is used by sites like github and others to push an agenda while making it 'acceptable' for general populace who for the most part has become so fixated on social justice that they fail to see free speech component of the issue. Code of conduct is a solution to problem that does not exist. It's also a blunt tool to silence and bully people.

What made hacker / programming community great is its relentless drive to make things better. Sometimes it means telling stupid people that they are stupid, or saying that stupid idea is stupid. This also means that you have a rowdy culture (which I rather prefer) which some labeled 'bro' culture. I think there is a distinction to be made here, 'bro' culture is very different from 'hacker' culture.

Hacker / programming community also has what's called natural order. Someone who contributes a lot to the project, which hundreds may benefit from, should be listened to. Have you seen House MD? While it gives no one the right to be jerks, I think immense contribution they make should afford them some leeway in dealing with the counter-productive or actions unrelated to benefit of the coding project. SJWs in general decided to jump in on the fray, using the highground they achieved on the platform field (e.g. github.com). What they are wrong about is that they believe SJWing is what made coding communities like github great. It's not. None of the coders posted their code thinking it will make everyone safe and sound from offense. They coded and pushed code because it's their passion.

SJWs are conflating the economic success of San Francisco to their dogma - it's wrong. Their whole stinking edifice will come crumbling down when people realize this is a load of crap.

In no particular organized manner:

• kludge - Not the most correct way to do something, but it works.
• backtick - the thing below tilde
• grep - find a text pattern in a body of text
• cron - A cronjob is something that can be scheduled to perform at given time or interval. You specify this in crontab.
• userspace - Also known as userland, as opposed to kernel. Kernel interacts with drivers, handles IO with CPU and memory, schedules system critical tasks, and so on. Userspace handles all the application resources, calls and so on. Userland interacts with kernel for hardware IO, interaction with filesystems, etc.
• map - a relationship between key and value. e.g. A map of A to B, A->B
• API - application programming interface, which often provides easy input output relationship in, but not to be used interchangeably with...
• SDK - software development kit, which is a collection of code and examples for developing with particular set of, but not to be used interchangeably with....
• Framework - which is basically a pre-structured way of programming. Sometimes providing a lot of...
• Libraries - which is a set of useful code that is included into the executable or into another library of codes.
• RESTful - something that has representational state transfer quality. Client need not know the structure of API to make REST requests. Simply put, using simple verbs like GET, PUT, DELETE, POST to say what needs to be done and passing parameters either as part of the request or as a payload in text and JSON.
• JSON - javascript object notation. A simple way to group information with curly braces.

gitlab too is infested, unfortunately.

https://gitlab.com/gitlab-org/gitlab-ce/blob/master/CONTRIBUTING.md

https://github.com/gitlabhq/gitlabhq/blob/master/CONTRIBUTING.md

Urgh

Very helpful thanks!

Makes sense to go Apache 2 if you plan on making sure that patent grant isn't an issue, but Apache 2 turns me off because of verbosity. If it's a big, important project, Apache 2 might be worth looking into, but for most of the stuff I'm working on I went with MIT because it's approachable by laypeople (non-lawyers) - aka developers.

Why Apache 2 though?

Javascript. Now I enjoy programming.

I'm being perfectly rational. Using projects that derives its value from toxic original is giving tacit agreement that such toxic original is in the right. It'd be like if I bought a ticket to a movie when all of its cast and staff advertises the fact on some TV interview that they donate to a cause that seeks to destroy my freedom.

There are a lot of great projects and languages out there, and you don't have to deal with Rust team's crap. You have freedom of choice. Move on. Let them rot.

1. Don't code on Rust.
2. Don't use projects that use Rust.

Images from the blog that looks like cross between surrealist paintings, HR Giger, and Cyriak from Youtube.

https://github.com/zick/ZickStandardLisp

A Lisp evaluator in Lisp.

It's really scatterbrained.

Version 1.0.0

npm install voatapi

Pick a project you want to get done in few different time periods:

• Short - A day or two
• Medium - A week or so
• Long - Month or more

Then start setting time aside for programming a little everyday to finish up a project to the point you'd consider 1.0. Move on to next project, and come back and improve the past projects as needed. Make sure you are writing the code with intent to be read and understood by someone else. Make sure you are committing them to github or other places where you are subject to public scrutiny.

C# and PHP is a fine starting point, if you are already familiar with it. I would also suggest experimenting with a few more scripting languages, like Perl. Python is a perennial favorite and you can't go wrong with it.

Picking up a functional language and experimenting with it will give you broader exposure than your run of the mill programmers. Just like you can't be a Wine critic drinking only one kind, software engineers should also try to extend their reach beyond the comfort zone.

Learning about concurrency, parallel computing, and asynchrony will put you way ahead of the curve. Web programming in general deals a lot with asynchronous event handling, so javascript is a good lead in for that. Learning the nuances of concurrency in different programming languages and frameworks also help, for an example, Node.js's approach to concurrency is very very different than Go's.

Learning about Linux fundamentals will help immensely. In particular, learning about UNIX philosophy, what kind of tools are available in Linux environment, and in general being comfortable with things like sed, bash, etc. I would recommend a book titled "How Linux Works: What Every Superuser Should Know" by Brian Ward.

I hope this helped. Best of luck.

Native App: Get Android Studio kit from here

Hybrid Webapp: PhoneGap or AppGyver

First, get yourself a good C++ book. I'd recommend something like Effective Modern C++.

Next, get yourself started with Visual Studio for an IDE and SFML for video/audio/thread library. I know a lot of game programmers poopoo the idea, but SFML is a decent way to learn the basic architecture of C++ game without having to go from grounds up.

Basic architecture is to run worker threads to update graphics, another worker thread to run the sound, and another to loop the game and so on. SFML gives you some thread management capability, so you have that going for you.

Here's an example code:

#include "GameEngine.h"
int main(int argc, char* argv[])
{
    GameEngine game;
    game.start();
    return 0;
}

The GameEngine will have implementaion like this:

void GameEngine::start(void) {
    this->loadSettings();
    int width = 0;
    int height = 0;
    this->mGameSettings.getResolution(width, height);
    this->mWindow.create(sf::VideoMode(1920,1200,32), "Game Title");
    this->mWindow.setPosition(sf::Vector2i(0,0));
    this->mWindow.setSize(sf::Vector2u(width,height));
    m_gameState = InitLoading;
    while(!isExiting()) {
        this->playGame();
    }
    this->mWindow.close();
}
bool GameEngine::isExiting() {
    if (m_gameState == AppState::Exiting)
        return true;
    else
        return false;
}
void GameEngine::playGame() {
    sf::Event currentEvent;
    while (mWindow.pollEvent(currentEvent)) {
        switch (m_gameState) {
        case AppState::InitLoading:
            {
                AssetManager assetMgr(this->mGraphicAssets, 
                    this->mSoundAssets);
                sf::Thread loaderThread(&AssetManager::loadAssets,&assetMgr);
                LoadingScreen initLoading(this->mWindow, assetMgr, this->m_gameState);
                loaderThread.launch();
                initLoading.run();
                break;
            }
        case AppState::AtMainMenu:
            {
                MainMenuScreen mainMenu(this->mWindow, this->mGraphicAssets, this->mSoundAssets, this->m_gameState);
                mainMenu.run();
                break;
            }
        case AppState::sp_challenge:
            {
                SpChallenge spChallenge(this->mWindow, this->mGraphicAssets, this->mSoundAssets, this->m_gameState);
                spChallenge.run();
                break;
            }
        default:
            break;
        }
        if (currentEvent.type == sf::Event::Closed || m_gameState == AppState::Exiting)
            mWindow.close();
    }
}
void GameEngine::loadSettings() {
    this->mGameSettings.readFromCfg();
    this->mGameSettings.setResolution(1200, 
        VideoSettings::AspectRatio::SixteenToTen, 32);
}

and you'd need somesort of application loop control:

AppLoop.h

#pragma once
#include "GameEngine.h"
#include "AppCommon.h"
#include <list>
class AppLoop
{
public:
    AppLoop(sf::RenderWindow& appWindow, AppState& appState);
    virtual ~AppLoop(void);
    void run(void);
    virtual void doInit(void) {};
    virtual void handleEvents(sf::Event sfEvent);
    virtual void update(void) {};
    virtual void draw(void);
    virtual void doOverlay(void) {};
// helper methods
    bool isReadyToExit(void) const;
    void setReadyToExit(void);
    float getElapsedTime(void) const;
protected:
    // reference to app
    sf::RenderWindow& mAppWindow;
    AppState&   mr_appState; 
    // draw loop draws this
    std::list<std::reference_wrapper<sf::Sprite>> mDrawSpriteList;
    std::list<std::reference_wrapper<sf::Text>> mDrawTextList;
private:
    bool        mIsReadyToExit;
    void        getAppLoopElapsedTime();
    sf::Clock   mElapsedClock;
    float       mElapsedTime;   
};

You can then inherit AppLoop in various game modes.

Enjoy.

I'd recommend looking into something like Rule 30 cellular automata. Coding this should be super easy in any language. Python would be a good start, as it's easy to pick up. Though it would still be called pseudo-random generator.