akoumjian

This is a great contest.

> never becomes superhuman

Arguably, we are already there. I think the idea of the intelligence not scaling far beyond what we have now is worth considering, though doubtful.

Where are you seeing this write up?

This is exactly what I wanted, love that the phone app has a native UI for agents like Pi instead of relying only on terminal renderers.

I think this is a neat idea. Is there a way to self-host the web app interface?

None yet. Any discoveries made with a possible impact risk would end up on the NEO Confirmation Page for follow up. As soon as an observation arc is long enough and gets a provisional designation, impact risks would be calculated and displayed at both NEOCC and JPL Sentry. We also do impact probability calculations and visualizations at Asteroid Institute.

The models only output text. Tool calls are nothing more than specially formatted text which gets parsed and interpreted by the inference server (or some other driver) into something which can be picked up by your agent loop and executed. Models are trained in a wide variety of different delimiters and escape characters to indicate their tool calls (along with things like separate thinking blocks). MCP is mostly a standard way to share with your agent loop the list of tool names and what their arguments are, which then gets passed to the inference server which then renders it down to text to feed to the model.

Is this related to Cloudflare?

I'm getting cf-mitigated: challenge on openai API requests.

https://www.cloudflarestatus.com/ https://status.openai.com/

I humbly post this little widget to help your team decide if some functionality warrants being a separate service or not: https://mulch.dev/service-scorecard/

Celery is great and awful at the same time. In particular, because it is many Python folks' first introduction to distributed task processing and all the things that can go wrong with it. Not to mention, debugging can be a nightmare. Some examples:

- your function arguments aren't serializable - your side effects (e.g. database writes) aren't idempotent - discovering what backpressure is and that you need it - losing queued tasks during deployment / non-compatible code changes

There's also some stuff particular to celery's runtime model that makes it incredibly prone to memory leaks and other fun stuff.

Honestly, it's a great education.

I also started my career with Django using 0.96 in college and 1.1/1.2 with my first industry jobs. It was a really empowering framework and it is surprising to me that I still pick it up today for new projects when appropriate. I started attending the Seattle Django Users Group and discovered there were a decent number of "ex-pats" from the Lawrence Journal-World who were there as it was being developed.

Before I knew it I was helping organize the user group including our weekly coffee shop meetups in addition to the monthly lecture gatherings. There were a lot of local startups (including some very well known businesses and non-profits today) very actively collaborating on these tools. Django was really evolving the way a lot of companies used software and automation.

It wasn't only the engineering, the community ethos of Django both at the local and international scale (and the Python community as a whole) really made it possible to branch out and accelerate my personal software engineering journey.

I've been liking pdm as opposed to poetry, as poetry uses some non-standard syntax in the pyproject.toml file. I had a lot of trouble getting hatch environments to handle changes to default python versions and the like. I like how pdm played nicely out of the box with pyenv if you're using it, otherwise manages environments directly.

"Type ahead" or "autocomplete" is absolutely a different type of problem, and often simpler. This generally falls into the use case where the searcher already knows the specific item they are looking for. Often the results are objects owned by or known to the user in question, or you are searching through a very limited and relatively static set of documents and topics. Reference documentation for software often falls into this category.

In my experience, you don't have to spend a lot of time thinking about scoring and relevancy for these types of search. Generally you only want to include a small edit distance in the results at all to handle misspellings.

This is so vastly different when you have a corpus of millions of documents about an encyclopedia's worth of topics.

> I do wonder how much deep search really matters when people only really expect to look at the first page.

Getting the first page to have the best quality and relevancy is much more difficult if the user is searching through something like scientific papers, stock video footage. It is a challenge in bridging the distance between ideas and expectations.

Broad full text search is incredibly hard to do well. I've had to build, maintain, and improve multiple search systems. The difficulty is largely dependent on the context of the type of search problem you are solving. A lot of complexity depends on your answer to some of these questions:

  - Does the searcher already know the result they are looking for? (If yes, much easier)
  - Are there subjective and objective qualities of the results which should alter the search score, sometimes separate from the text being indexed? (If yes, much harder)
  - What is the quality of the text being indexed? (If end-user provided, this will vary widely)

Ultimately, building good search is often a struggle against providing the best possible results between searcher intent and incomplete document evaluation criteria. People never really think about when a search is working really well, but they definitely know and complain when it's working poorly.

The only purchase I've made on Wish was a similarly "too good to be true" set of flash drives. When I received them I tested them out on a linux live image and sure enough they were simply programmed to report having much more storage than they did. I did get a refund, but you can bet the products are still there.

Self-promoting a little utility I wrote that helps guide teams on whether your service boundary is a good idea: https://mulch.dev/service-scorecard/

The service scorecard asks a bunch of reflective questions about the ramifications of making some set of functions a unique service and points its benefits or lack thereof on a scale.

I was hoping somebody would make this.

I humbly offer my service scorecard as a tool to try to gauge whether a piece of functionality deserves an independent service:

https://mulch.dev/service-scorecard/

The interaction is not the worse thing about npm audit. The security model of the tool has a big hole depending on how you use it: https://mulch.dev/blog/CVE-2020-5252-python-safety-vuln/

In essence, if you are scanning an environment that is already compromised, `npm audit` results can't be relied upon if you are running it in the same environment. It should be self-evident but I'm sure plenty of people use the tool this way.

I know this is now an old thread, but just seeing it I feel it's worth responding. It is absolutely possible to be earnest and sincere in communicating real feelings and conflict without resorting to this ridiculously aggressive communication style. The alternative does not have to be fake or polished over.

The nasty pretend exchanges between coworkers on this page is a really depressing way to highlight this tool: https://www.qt.io/design

The comments here on HN seem really knee-jerk. Some people like to claim no one is made to feel erased or reminded of their otherness when they hear this terminology. Some people seem to think we can't walk and chew gum at the same time.

What I see are people criticizing these changes because of a fear that perhaps, on some level, they have participated in a language and a culture that continues to demean or ostracize others. It is not a good feeling to realize this. Please ask yourselves why you are so attached to using terms like master/slave. If it had been different from the start, would you even care?

Here is PyUp (safety) response: https://pyup.io/posts/patched-vulnerability/

Really astounding to see them publish this article today. I have a CVE that's about to go live regarding auditing tools like this one.

I contacted Snyk a week ago to point out that their audit tool (just like npm audit, and others) cannot fundamentally protect you from attacks like this when installed to the same environment as a malicious package. Almost feels like they are trying to get ahead of it.

I was withholding the CVE while other tools are wrapping up their mitigation strategy. NPMJS and Snyk folks basically shrugged their shoulders. This is kind of forcing my hand to publish now.

Well, here is the blog post explaining:

https://mulch.dev/blog/CVE-2020-5252-python-safety-vuln/

And here is the snyk proof of concept:

https://github.com/akoumjian/npm-audit-vuln

TLDR; Don't ever use the `npm install` version of Snyk. Use the binaries or the dockerized version.

What video codecs do you support as inputs?

I've found that methods like this don't actually help me avoid procrastinating. The key for me is to remove the psychological barriers to starting a particular task.

I think Getting Things Done has a good approach by dedicating time to figuring out what the Next Actions are for any given task / project. The idea is that it is way easier to start on a task if what's listed is a concrete action. For example, you might add an item to your Inbox like:

"Add better search for project X".

You might avoid a task like this indefinitely. With GTD, you take regular time out of your day (it's how I start every morning), and you take your Inbox items like above and figure out what the literal next step should be to achieve the goal. So the above item might become:

"Search google for adding search to a django project"

There is something about taking the mental task of figuring out what the Next Actions are, and putting it into its own process that removes a lot of the hurdles for me.

Wasn't there another company or two that just did specifically this?

Looks mildly inspired by itty!

I suppose if you already have an existing service component that encapsulates authentication, authorization, business logic, notifications, and all that other jazz, then use flask is an excellent way to wrap that to produce an http api.

This was a good general list of things to consider for scaling any web applications. What I've noticed though is that all my flask apps, after adding in all of the standard components, eventually converge on a Django-esque setup anyway. So now I just use Django, and if I don't want to use a particular component (ie: orm, templates, whatever) I don't, or I swap it out. On the other hand, if I do want to use those components, they are right there.

No reason to be hostile. We investigated months back when we got reports from our users, who are professional videographers, that videos were showing up much worse in some browser situations than others. They sent us screen shots, and upon investigating found that on almost every clip we were getting better results using two different flash players we had access to than the native decoder.

I don't have some big official report because, well, that's not my job and I have better things to do. You're welcome to investigate yourself if you're concerned about it.