git-pull

Commercial games are shipped on a quick schedule, so this doesn't always apply unless its a project that's maintained/cleaned up.

What I'd like to see (2D games): Permissively licensed, widget / sprite tooling, handling of rotation, blitter, canvas resizing, scaling.

Anecdote: I made a request for a Zelda clone to make their code available via a commercial-friendly license here: https://github.com/solarus-games/solarus/issues/826

Look at this, well-maintained C++ bits and pieces wrapping around SDL2, that could easily apply to more than just this game:

https://github.com/solarus-games/solarus/tree/dev/src/core

https://github.com/solarus-games/solarus/tree/dev/src/graphi...

If something is open sourced, I highly prefer it if generic parts are available for everyone to use on their own projects. Keep the creative work proprietary / GPL / etc.

One reason we do open source is we don't want to perpetually reinvent the wheel. Projects last longer when they have users. And in this case of a library, your stuff is directly used by developers, further increasing the likelihood of reciprocal contributions / sharing the burden of maintenance.

I can't imagine how boasting about superiority working out in well in the end. There has to be an Aesop's Fable short story for this.

Bragging about being smarter is a standing invitation to receive passive aggressive behavior from others. People will unfairly try to find flaws, and who can blame them? They're acting innately better than their peers - while at the same time not being wise enough to be humble / modest.

I also worry it ends up having a person with potential ending up hiding behind a cryptic / abstract facade, afraid of failing when not being an instant prodigy at a new skill. Don't we will have to work our way up and build a track record of some sort?

What does being intelligent mean anyway?

Ultimately, if someone wanted to be recognized as smart, wouldn't at least some "normal IQ people?" have to understand and appreciate the value of something they synthesized/made?

Thanks for this and the additional information above. Both answers were informative.

This is the first time I heard of AcousticBrainz and its sig (https://acousticbrainz.org/e73f3d92-4e9f-4db4-943a-41978d9db...). Nice! From the ones that brought us MusicBrainz right?

what do you have in mind actually? I am not sure since the goal here is to play the music on the device from which you access to the server.

ncmpcpp is a music client, but for the mpd music server. Not sure if LMS <-> MPD do the same things. compare ncmpcpp to mpc, but w/ ncurses + c++. It has directory-based navigation which makes it easy to move through music.

Look forward to watching this project grow!

Amazing. Requests:

- Would prefer a permissive software license. Not much benefit to GPL. I've seen nice projects I'd have contributed / shared with where collaborative opportunity didn't happen. Too many obligations, sweeps in too many situations, and a lot of gray hairs explaining it being a net negative. I try to encourage a philosophy of YAGNI when doing open source licenses, sheerly for the sake of backward compatibility with licenses.

Don't you want your code / project to be inter-operable as possible, even with other licenses? Do you want to make development contributions streamlined as possible (even from the parade of horribles, e.g. the corporation profiting from your work with no intention of reciprocal contribution? Why impede their success? It's not your loss), or do you want potential contributor's interest to derail into a cost-benefit analysis of running afoul of GPL terms until they find an alternative?

- ncurses / ncmpcpp-like frontend. vim keybindings

- directory-based navigation. easier to navigate around, supports file structures where id3 tags aren't in place yet

Questions:

- Any info on the recommendation engine? How does it work?

- Does musicbrainzId support include id3 tagging?

Congratulations again on the project!

We use https://www.figma.com at work. Give it a shot!

https://www.figma.com/templates/wireframe-kits/

They can paywall / block incognito all they want.

Just delist the (paywall'd) articles. That's the annoying thing - when articles come up on Google and you can't read them. Please fix this.

If people want to pay, that's fine. Perhaps ISP's should pay for these websites via their plans so there's no more need to login.

I don't want to login to something just to browse a feed. I believe people would be happy to pay for these websites, but in a convenient way, ahead of time. Allow IP ranges, create a browser plugin that reauthorizes the site session even in incognito / w/o password saving. Innovate like Spotify did.

Annoying and badgering the user is 101 UX antipattern. One reason some don't buy is they don't want to encourage it.

It's fair to hold them to a high standard because many of these websites are articles and presentation is supposed to be a forte. You don't battle the adblockers and incognito modes - you fight to make it easier and more convenient for your readership.

Title: please note this is a review of the book here: https://www.amazon.com/Private-Government-Employers-Universi...

Aside: If you like to compare-contrast US<->EU, I found this paper interesting: Why Doesn’t The US Have A European-Style Welfare State? (2001) https://scholar.harvard.edu/files/glaeser/files/why_doesnt_t....

It's not at that point yet. PRC does have a garrison inside HK but they're sitting still. It's possible they could go in plain clothed to collect info and provocateur to discredit the protesters. It'd cause a pretty big meltdown if they were busted doing that.

Aside from that: HK has control over its statutes. https://www.elegislation.gov.hk/index/en/subject

Basic law (the part PRC plays a role) is the constitution. For an overview: https://www.basiclaw.gov.hk/en/facts/index.html

Aside, Here's a better article: http://www.thestandard.com.hk/section-news.php?id=210397

Good find, I was looking at https://github.com/itsonecube/jtk/blob/3d28ed3/LICENSE

What kind of license is it? Any possibility of ISC / MIT / BSD?

Nice to see CMake!

And also nice to see an effort to make something lighter than glib.

It may be worth looking at BSD's base system in /usr/src to see code you can use as a reference, or add in a generic way. Take a look at #ifdef in ISC/MIT/BSD applications to see if you can port it in to offer portable functions.

Hm, examples: https://github.com/tmux/tmux/blob/master/compat.h -> https://github.com/tmux/tmux/tree/master/compat

For inspiration, all SDL2 is a cross-platform wrapper which probably has chunks that may be useful: https://github.com/spurious/SDL-mirror/tree/master/src, SDL_net: https://hg.libsdl.org/SDL_net/file/c5b3c4171459

Maybe the above is relevant / helpful / an inspiration.

We need a lite, portable glib alternative. I'm guessing it must be hard to do. I wish there was a a library where we could just pick what we want and not have to buy into an object model, which inevitably entails a lot of dependencies downstream.

Good luck with this! Look forward to watching it grow. Starred.

Look up Yamato battleship on youtube (https://www.youtube.com/watch?v=zYrj3gzXgeA, https://en.wikipedia.org/wiki/Japanese_battleship_Yamato)

The interpretation I've found is after these battles (with US Carriers vs Japanese battleships in WW2) the tendency was to favor aircraft carriers and phase out battleships.

One big reason is how versatile and integral a carrier is in to a fleet. Carriers can send out scouts, attack, defend from hundreds of miles away from the carrier (where the ship is beyond the horizon, https://en.wikipedia.org/wiki/Radar_horizon).

The weakness of a battleship is the target has to be tracked, and I think the best way to do that would be aerial recon. Battleships like Yamato then had pontoon type scout planes, but nothing like a carrier.

Without a carrier accompanying it, Yamato wouldn't be able to create a defensive perimeter of fighters to ward off dive bombers. I don't think it'd be able to effectively counter a fleet with carrier in the end.

More on Yamato: https://en.wikipedia.org/wiki/Operation_Ten-Go

Anyone here know more about this and can link some vids/resources on naval stuff?

I don't think that's what they're saying though. They're talking about what the mailbox while it's in use. I didn't find anything mentioning boxes being property of the USPS, they use the term "authorized repository." When it's in use, it's still property of the private entity, but it's usage is subject to the rules of USPS. (I'm not a lawyer)

My understanding it they can remove the USPS box (looking at what postal workers said on Quora), but they wouldn't be part of the mail system anymore. I guess they could have mail forwarded to a new box, or else it'd be undeliverable.

https://www.nytimes.com/1981/06/26/us/justices-upholds-law-p...

Writing for the majority, Associate Justice William H. Rehnquist said that no one was required to receive mail or to have a mailbox but that once a postal customer provides a box for receiving mail he implicitly agrees to abide by postal regulations on its use.

Audio/transcript: https://www.oyez.org/cases/1980/80-608

Used fire before and find it works quite well. Especially after dealing with click and having difficulties with it.

The neat thing about fire it maps a python file directly to a CLI. If you're in a pinch and want to be able to test a script easily (without having to wire in tests), this tool can help.

The docstring parsing will be very helpful. Especially since fire works by reading through a file.

Also nice work on the NamedTuple support (https://github.com/google/python-fire/pull/161)

I never knew fire had support for completion. Nice!

Restricting the queries is backwards. You expose should only expose the few that makes sense in the domain of your app, and optimise for those.

With exceptions:

Preventing endless recursion: Or else it'd be possible for a client to timeout with queries [1]. In graphene recursion can be checked via `info.path`.

Calculated / slow fields: Makes more sense to have dedicated objects if calculations are involved, so if they're lists/connections, there can be limits imposed for how many can be grabbed at a time.

Sometimes the only way to be sure is to only allow access to these objects if they're a direct ID lookup at the root, e.g:

repos(id: <ID>) -> stats -> TotalLikesForAllIssues.

Assume that if cold and uncached, it could take <1s to calculate that. Imagine if we were to have that ran multiple times:

User -> repos(first: 20) -> stats -> TotalLikesForAllIssues.

So in my case I want to make the data available, but it's not always a direct mapping to SQL. And I'm also making rules inside where the client is limited in how, and how much they can query.

[1] Further reading: http://facebook.github.io/graphql/#sec-Fragment-spreads-must..., https://github.com/graphql/graphql-spec/issues/91

GitHub page: https://help.github.com/cn/articles/github-and-trade-control...

Ukraine: https://www.treasury.gov/resource-center/sanctions/programs/...

Iran (from a few days ago: https://news.ycombinator.com/item?id=20493699) https://www.treasury.gov/resource-center/sanctions/programs/...

I want a way to legally opt out of other such companies collecting and aggregating private data about me.

Compare a desire to legally opt out (after checking a box, agreeing to a privacy policy you never read, having your data from 10 years ago - with a chain of custody/dispersal that's probably untenable, if not impossible, to map by now - synthesized by a third party) to GDPR's concept of consent:

"The key point is that all consent must be opt-in consent, ie a positive action or indication – there is no such thing as ‘opt-out consent’. Failure to opt out is not consent as it does not involve a clear affirmative act. You may not rely on silence, inactivity, default settings, pre-ticked boxes or your general terms and conditions, or seek to take advantage of inertia, inattention or default bias in any other way. All of these methods also involve ambiguity – and for consent to be valid it must be both unambiguous and affirmative. It must be clear that the individual deliberately and actively chose to consent."

Source: https://ico.org.uk/for-organisations/guide-to-data-protectio...

Wish list:

- international employees (US, European countries)

- better support for employees across-states (they already do many things well in this regard)

- taxes

- general accounting

- atlas-type stuff (bank, incorporation)

- maybe a specialized account manager / team to handle the above (I guess it'd be region-based CPA/lawyers?)

Some of those are sophisticated things, but having one hub to view/manage it all from the top down would save oodles of time.

Aside: Gusto's support has been very helpful, even as an employee, when I contacted them directly they went out of their way to help me solve a payment issue.

My point is - configuration takes time. Having a dev loop to gain velocity is necessary, as is having to deploy. I believe MVP's flouting 1 week figures aren't going that far. Maybe showing it off during a presentation. I'm assuming a public demo with a backend where you can share the URL, register/login, etc.

Te output having to land somewhere. (More than half?) the time pushing dist/ files to a static host won't cut it, even for an MVP. From the beginning, the quickstart tools and workflow become a burden. Cases vary widely, here's mine:

With create-react-app, I don't want to use the included index.html / default dev-server config. I'd be using django-webpack-loader to load the webpack entrypoints. That requires webpack-bundle-tracker [1]

In my case, it'd also involve compiling via webpack, collecting static files and pushing them to S3.

[1] To be fair, you could use https://github.com/timarney/react-app-rewired to add it.

The stack I suggested is opinionated for an MVP. I won't defend something so specific to my personal case.

However there's more than that at play. Let's just assume bootstrapping the basics, with a requirement there's a backend and it has to be deployed:

1. If there's a requirement to have a backend connection and deploy the mvp, that rules out create-react-app / @vue/cli in most cases since it'd be too custom. The app would need to be ejected. But even further, the ejected app is overengineered.

The byproduct of create-react-app's ejected output is so bad I wrote https://github.com/tony/react-typescript-vanilla-starter, https://github.com/tony/vue-typescript-vanilla-starter simply for the sake of getting a minimalist webpack+typescript+hotreload+prod build config working.

I found it challenging to patch together webpack + ts + react/vue from scratch.

2. Going to a stack outside of our usual stack takes time to relearn. Not necessarily a bad thing, but people are going to be rusty.

It takes 1-2 days just to get a frontend setup working the way I want. What create-react-app / @vue/cli gives out of the box isn't sufficient if you're connecting to a backend.

I like graphql in the backend and having it generate a schema file, and getting typescript typings from that, so all the data structures align nicely.

Add pushing to heroku / some cloud service via fabric, that'd easily put me at 1 week.

It's after the first week stuff really comes together. Then there's a reliable hot reload loop, scripts, familiar stuff you're used to is prepped.

I don't like the 1 week thing because I think you'd be stuck inside a framework/starter kit that'd hold down what you want to build. I think a month is minimum if you wanted to impress and get your idea across.

Don't give coding quizzes if they can provide better evidence of their ability.

It's unfair in the least, rude at the worst to pigeon-hole "senior" programmers into scenarios / pop quizzes.

Let them show off recent personal projects. They'll probably have no problem spending a weekend hacking on something they're passionate about.

Be a serious employer:

Convince the best programmers (whatever that means) why they should reorganize their life around your business:

- Pension plans / job security are nice. It's a good motivator to know that there will be an annuity when they're 60 / 65 and would rather spend time with their family.

- Union contract (or something comparable) or a labor system with robust employee rights and unemployment insurance. It's pretty unfair in the US with at-will employment.

- Have strong financials. Be a business that'll be around in 10 years. Can your business keep paying employees if it's in the red for a year?

If you don't offer the above: Why feel deserving of the best?

I'm being facetious on the above points: It's tech, it's a fast cycle and inherently unstable. But when orgs talk about hiring - it irks me to see the entitlement employers have when they have little investment in the welfare of employees as persons (and families)

There's a lack of financial incentive to build TUI apps. It's a niche. It's awesome for power users: no lag, all keyboard driven, raw structured data. But businesses buy slack / trello / salesforce for swathes of people. That sort of thing doesn't happen if the following is simply limited to programmers / power users (and a cross section of those at that)

I haven't seen any C++11+ wrappers for ncurses... until, recently: https://github.com/clangen/cursespp, https://github.com/Praetonus/Ncursescpp strange license.

There are people who are on the forefront of terminal tech, examples are stuff by https://github.com/saitoha, https://github.com/mitotic/graphterm

There is hyper: https://hyper.is/ It works on windows. But by then, you potentially have the lag time most terminal users want to bypass.

For windows, maybe https://github.com/microsoft/terminal will encourage more terminal innovation by bsd/linux -> windows crossovers.

On Linux, try this: https://sw.kovidgoyal.net/kitty/

I wrote a book on tmux that briefly touches terminal stuff. I still get confused when terminals are miscolored and emit junk characters. There's a lot more going on behind a terminal than meets the eye: https://en.wikipedia.org/wiki/POSIX_terminal_interface#Gener...

Attachment Theory Deep Dive, 15+ hours, Dr Kirk Honda, Psychology in Seattle. (The series is paywalled behind their patreon.)

Example: https://www.youtube.com/watch?v=Ji2QKcKqY7U

They are above the quality of a normal uni lecture, but not polished as a Teaching Company/Great Courses thing.

http://www.psychology.sunysb.edu/attachment/online/inge_orig...

http://labs.psychology.illinois.edu/~rcfraley/attachment.htm

For adult attachment Cindy Hazan is everywhere.

In the last 12 months, I begun understanding:

- what attachment theory was, as a tool/framework analyze myself, others, and the world around me

- about western philosophy (Plato, Socrates, Marcus Aurelius)

- about eastern Europe or it's history (e.g. Alexander the Great, Siege of Constantinople, the Crusades, Subutai)

- TypeScript

- how to say hi in Polish or Ukrainian

- how powerful desktop PC's are compared to laptops, esp. at compilation (that includes webpack)

Amazing work

- C++

- Has a python API, this opens up a lot of possibilities. Language server protocol, linting and formatting tools, perhaps mypy

- Highlighting

- Jedi integration

- Being able to glue python and c++ to get it to work together in itself is a feat (where I've tried and failed before: https://www.git-pull.com/#scrapyard :P)

How did you like working with QT?

GPL is okay, except it precludes those when open source ambitions incompatible with that license. BSD/MIT/ISC/Apache projects can't pull it in. Too much paperwork to pass onto a layperson, a potential contributor.

Also nice CI loop with appveyor! re: https://github.com/JaDogg/expressPython/blob/master/appveyor...

Please keep working on this

Simply state it's a startup.

It implies there's a runway.

It's normal for startups to run out of capital.

Focus on technical aspects and cultural stuff that was functional. Like slack / github reviews / trips / etc.

It's okay to say if there were snacks / coffee machines you didn't like / local restaurants in delivery range weren't good. Those are fair game. Snacks imply you stay around and code :)

If interviewing for an employer not familiar with startups roles lasting <three years, let them know the experimental nature of the space. Founders move on/vc capital dries up because the market gets saturated (Imagine raising for a rideshare / delivery up in 2010 vs 2019)

1. Clone the source

2. Try to build it

3. If there are tests, try to run them

Just from doing this many times over, I learned a lot about programming.

Also fork the repo, then do `git clone <url>` for the original repo, `cd repo`, then do `git remote add yourusername <yourgithubforkurl>`

To ease the above process, I created vcspull: https://vcspull.git-pull.com

Here is an example of my vcspull file: https://github.com/tony/.dot-config/blob/master/.vcspull.yam...

This also helps studying, read code, and also do open source in general since it's easy to setup the original repo and the fork.

For generic open source: Download source, check README.md/rst to see if they are testing/development instructions. Check .travis.yml commands, those are showing what packages/steps are taken to build and probably test the code

If it's node: do `npm install` and check the "scripts" in the package.json. Those commands can be run like "npm run <task>"

If it has CMakeLists.txt, it uses CMake. Download and install cmake, then do `cmake .`. cmake will let you know if you're missing libraries and those are easy to google package names for. Then `make && [sudo] make install`

If it has Makefile.am/autogen.sh... download and install autotools/autoconf/automake. Run `./autogen.sh`, then `./configure` (google for package names of any libraries that show missing headers, .h, or symbols). Then `make && [sudo] make install`

If it is python, and there's a Pipfile, download and install pipenv. Then do `pipenv install .`. If it has requirements.txt, `pip install -r requirements.txt`

Carried foreward, if the project has anything resembling a package manifest (e.g. Gemfile, composer.json) google them to find the appropriate package manager for your OS. That gets you 75%-100% of the way to running locally a lot of the time.

For the more complex projects, they typically have dedicated setup instructions and sometimes very detailed overviews (e.g. https://github.com/OpenTTD/OpenTTD/blob/master/docs/Readme_W..., https://devguide.python.org/setup/, https://www.kernel.org/doc/html/latest/process/index.html)

Reading the source of your favorite interpreted programming language can be rewarded, e.g. https://github.com/python/cpython

It's hard to draw broad strokes about this. But I really really deeply like HK.

One thing about Hong Kong that's a lot to take in is how western-friendly the culture is. I think there was a western news channel playing while I was on the MTR last time.

I am guessing some may find the rallies annoying. They may view them as hooligans, but even the cynical still are happy with HK being HK.

To understand more about HK system of government, check out the basic law: https://www.basiclaw.gov.hk/en/facts/index.html, https://www.basiclaw.gov.hk/en/basiclawtext/index.html. This effectively serves as the constitution of HK.

And it's a weird thing: Because it's effectively a client state constitution. heh. They have their own judiciary, they have their own case law, but the people of HK cannot amend their constitution.

P.S. I haven't read the latest part of the extradition law they're trying to pass (anyone have it?)

Using graphene at work.

Absolutely love graphql as a technology. The pagination and ability to structure a query to pull a lot of data is nice.

As for some of the other comments - it's true you can't just write any query: but you can always add new fields, lists, connections (basically a pagination-friendly list), etc against arbitrary things on the backend. It's your backend, you control what data you serve.

The graphql-python stack is layered like an onion (graphene on top, graphql-core inside). You will probably be doing something like flask-graphql or graphene-django on top of that.

There is a huge negative for python <-> graphql for us, and it's the error system and promises. Perhaps this is what graphql servers in JS are like, but graphql-core hijacks python's error system by wrapping fields in promises.

So graphql-core is acting very very true to graphql's implementation in node: to the point it creating a mountain of breadcrumbs in sentry.

It also overrides the "next" built-in and tries to emulate express-style callbacks. Another thing ported from node into python that doesn't translate well imo.

Aside from that though: graphene has been really speedy, fast to work with. Documentation is getting nicer. The developers on the issue tracker are very nice. And as a general graphql thing: https://github.com/graphql/graphiql is really nice!

And one more graphql thing: It's typed. In a big API, being able to lay out stuff like that goes a long way. We're generating typescript types via schema.graphql output, and response types via relay. In a real big frontend project, it pays off a lot.

I recommend giving graphql a shot.

Location: Chicago, IL

Remote: Yes

Willing to relocate: No, sorry! Only remote - happy to travel onsite!

Technologies: Python, TypeScript, React/Vue, OAuth, Stripe, APIs (graphql/rest)

Website: https://www.git-pull.com

Résumé/CV: https://cv.git-pull.com

Github: https://github.com/tony

Email: tony at git-pull dot com

10+ years in startups. Open source background. Looking for remote opportunities. Team player!