git-pull
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.
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?
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!
- 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!
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.
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....
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
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.
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?
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
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!
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
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...
- 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.
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.
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.
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.
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)
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...
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.
- 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)
- 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
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)
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
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?)
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.
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!