Ask HN: How do you track issues, todos, features? - <AUTHOR> For the past few months building our app, we've used BugHerd for three main purposes:
1. Tracking issues
2. Posting to-do items
3. Noting new features
BugHerd is great for client websites, but we feel like it's not quite right for a more long-term build.
Specifically, our lists get so long (we have a few hundred items in the Backlog) that it becomes difficult to find certain issues. Plus, organizing them isn't that smooth.
I know some use Jira for this sort of thing, but it feels pretty old-fashioned. And, I know there are many other products, but researching all of them seems daunting.
So, I'm going to cheat, and ask: What do you use? Why? Do you like it? <comment><USER2> At my company, over the last 6 months we've tried Trello, Pivotal, and Sprintly. At past companies I've used Trac, Jira, and Asana. And for the last 7 years I've kept a daily todo.txt, where I append today's date and the 1-2 things I want to try to get done, adding detail as I figure out plans. (This is the only task tracking tool I've recommended that coworkers adopt and are actually using years later)

I've come to conclude that no tool for this will ever satisfy everybody's needs perfectly. Part of that is that everyone has different priorities for their task tracking tool. And frankly, some of those priorities are directly contradictory. What's trackable and detailed to a project manager who lives in the task tracker is heavyweight and clunky to an engineer who sees it as a bookkeeping annoyance. My personal todo.txt is exactly me-focused and only changes when I want it to, but it scales to exactly one engineer.

I think you just have to pick something and use it. Changing tools just adds friction and costs you familiarity. Ideally, the people who have to interact with it the most choose the best tool for them.

<comment><USER3> Same here, I have to track at a personal level, I'll update the Jira etc... But I still have to track it. I've tried Task Coal, org mode, Remember the Milk, etc... But at the end of the day I always go back to a Simple text file.

For family stuff (eg: shits that has to be done before we go on holidays) we've been using Google doc which allows concurrent access all sort of devices.

I don't use Google doc for my personal list because I'm still more efficient at whacking text in vim. I need evil mode for Google doc :-)

<comment><USER4> Actually thinking about it, a google doc with my todo list has been about the most efficient tool I have used for task management.

<comment><USER3> Not just TODO lists:

[https://news.ycombinator.com/item?id=10610840](https://news.ycombinator.com/item?id=10610840)

</comment></comment></comment></comment><comment><USER5> I would recommend Jira - get the GreenHopper plugin to make it less "old- fashioned", but it's the right tool for the job. You can customize it if you want to go down that rabbit hole, but the built-in workflows should get you started. Projects, epics and tags should solve the problem of finding issues. Set each client as a project, or more likely as an epic so you can have one view for your developers / designers that splits by client.

Currently using Pivotal Tracker after coming from a Jira shop, and it's awful. Others seem to like it, but it's too simplistic for my taste. Even something as simple as "A blocks B" isn't possible, and seems to be by design.

<comment><USER6> +1 for Jira. It's clean, simple and easy to understand.

<comment><USER7> I'm a fan of JIRA but wouldn't really call it "clean, simple".

</comment></comment></comment><comment><USER8> We're using Asana at the moment. It's decent, but flawed, so I'm not happy. We've been through Pivotal, Lighthouse and Trello, and one team is still using JIRA.

That said, our use case is explicitly tracking backlog — _work_ that needs to get done. My philosophy is that any issue tracker that is treated as a database and that disassociates items from assignments will decay into a pile of rot almost immediately. Especially bugs. Don't put anything into the database that does not represent work to be done within the next few days.

So we use Asana as a collaboration tool that brings together stakeholders, information and assets. Typical workflow: Account manager brings issue to attention of project manager, who brings it to attention of developer, who does the work, sends it back so customer can be notified. Task goes away. Another typical workflow is an actual project, with steps to complete and a launch timeline.

The only way, in my experience, to manage _bugs_ is to give them to a project manager. The PM triages: Forget or hide the unimportant ones away in a drawer, and fix the important ones ASAP. Bugs that linger aren't important enough to consider. Sometimes everyone is too busy and the bugs are important but not critical; schedule a single day of the week when everyone puts aside their main work and plow through the bug backlog. We call them "bug days".

For new features, use something else, like Google Docs. But it will rot, too. It's better to do whiteboard sessions that are turn into discrete tasks and discrete projects.

<comment><USER9> Can I ask what you dislike about Asana?

I haven't used it. What's the biggest feature of Asana, and how is it flawed?

<comment><USER8> Oh, where to start!

So Asana is a todo list. Everything is a task. Tasks are assigned. Tasks can have subtasks. They can also have comments, tags and attachments. The top- level organizing construct is the project; projects have tasks and also team members. Oh, and within a project, tasks have order (something which doesn't really work in practice).

So far so good. Most of the problem with Asana is in the UI. Asana is all about lists. Unlike Trello, for example, Asana only has one view: A vertical list of tasks. This list UI is very much like a classic outliner or even text editor, in that there's almost always a cursor that's editing something. You can use the keyboard to navigate around. This leads to some immediate weaknesses: Since there's usually a cursor, typing something will typically have the text land in some random, unpredictable place. Hitting Enter creates an empty task. So if you're not super careful, your lists will be littered with errand characters and empty tasks.

This information-dense view means there is never a place to "rest". I can't keep a single task open. There's a split screen that allows you to maximize a task, but it's not quite the same. So in Asana, you never feel like you're in a specific location. It's always the list. It's easy to get lost because there's little or no sense of hiearchy, even though the data model is hiearchical. This UI is doubly problematic because Asana is a heavy single- page app (it takes several seconds for it to "boot") that doesn't lend itself to being opened up in multiple tabs. So it's not very web-app-like.

Really, this kind of editor-like "live" UI seems more appropriate for personal todo lists, but not for collaborative ones. In my mind, a task is a kind of mini project, and a task with subtasks is a _bigger_ kind of mini project (usually you use these for multi-step tasks like launches or big features), but Asana treats them all with equal lightweightness. In fact, in your "My Tasks" view (also a list), Asana will comingle subtasks and top-level tasks, making it confusing because subtasks don't carry their context with them — so "My Tasks" will list something like "Add CNAME", which on its own makes no sense, until you click on it and see that it's a subtask of "superproduct.com launch".

There are lots of minor flaws. The editor is horrible — pasting and undo/redo tend to make the cursor lose its place, there's basically no support for pasting code (no syntax highlighting), the keyboard shortcuts are non-standard and weird (they use tab (!) instead of alt or ctrl as a modifier), and you can't turn off the stupid rich text mode (no Markdown). As mentioned, startup time is bad, and the main page loads as a POST, so if you restart the browser, the browser needs to ask if you "want to submit this form", which is bizarre.

The more I talk about, the less I like it. Unfortunately, so far I haven't found any alternatives that look good enough to migrate.

</comment></comment></comment><comment><USER10> I use a TODO.md doc in the project root as long as it's <50 lines of todos and issues. You can use `- [ ]` to create checkbox lists in markdown.

For a larger project I use GitHub issues with tags.

<comment><USER11> This is a similar method to what I use as well.

I even wrote a Vim syntax plugin for the todo files: [https://github.com/tomswartz07/vim-todo](https://github.com/tomswartz07/vim- todo)

</comment></comment><comment><USER12> This is a fascinating problem, the "Project Management Tool dilemma": there are hundreds of software alternatives out there, and there seems to be another one coming out everyday, and nonetheless there is always demand for new solutions, and no clear leader in this segment (altough Jira is pretty ahead, and Trello is the strongest newcomer). I've been struggling myself trying to find one in my new work context. I guess there are so many project use-cases, that it's impossible to have a one-size-fits-all solution (and get the pricing right!).

It could be fun to have a global online poll to see who's using what, to know which tools are the most popular, just out of curiosity.

</comment><comment><USER13> We've been using Phabricator[1], a spin-out of Facebook, and love it. It's perfect for technical teams, and usable enough for the rest of the company.

[1] [http://phabricator.org/](http://phabricator.org/)

<comment> jon-wood Even if you're not in the market for management software you should go and look at their website. I really want to use it just because they had the balls to advertise Awesome Edition and Serious Business Edition.

</comment></comment><comment><USER14> We use Jira Agile, like a lot of startups. The metrics portion is really sophisticated which is a plus for management, but from my experience most devs hate working with Jira.

I've also used Trello with teams which I find more pleasant especially if designers need to give you assets, for comment threads, etc.

I mostly use a simple todo.txt for my own personal projects. Though I've been by somewhat migrating these into Bitbucket issues.

A few months ago I wrote a Python script called Jello (Jira + Trello) to copy our sprint tasks from the Jira API into a Trello board via their API. This was pretty awesome and satisfied the devs, but I didn't find the time to build 2-way sync, so someone manually updated Jira at the end of the sprint. Someone built an even better version called Gitlo (GitHub + Trello) [1] which front paged momentarily last week.

1: [https://news.ycombinator.com/item?id=10572701](https://news.ycombinator.com/item?id=10572701)

</comment><comment><USER15> I'm a solo developer.

For short term, post-it notes and legal pads. There's something for me about having those TODO's constantly in my face. I always get them done. And it feels so good to crumple that ball of paper and throw it into the bin. Each sticky is 5-30 minutes of work.

For longer term/planning: Trello. When I'm ready to tackle something, I convert the Trello card into a sticky note, archive the card, and get to work!

Sometimes when I am feeling super unproductive/lazy, and have a buildup of sticky notes, I'll convert all those sticky notes into a neat 1 page legal pad page - handwritten, with checkboxes. By the time I'm done doing converting (and crumpling up all those sticky notes!) I feel rejuvenated enough to work on that second pass.

I love throwing stuff away. When I am SUPER unproductive, I'll tear away the blank part of the sticky note and throw that away.

<comment><USER16> Any trick you use to get all your tasks into Pomodoro (<30 min) size? How do you handle a coding task that might take half a day?

</comment></comment><comment><USER17> Still a happy user of FogBugz.

[http://www.fogcreek.com/fogbugz/](http://www.fogcreek.com/fogbugz/)

</comment><comment><USER18> I'm actually working on a new start-up to try to take a stab at this problem. Would love to get some beta users, if any of you are interested: [http://hellofocus.com/](http://hellofocus.com/)

<comment><USER19> Could I politely recommend that you put some screenshots on your front page. Generic statements and stock photos really don't make anything more than a superficial impression.

I'd like to get an idea of what I'm signing up for before I commit.

<comment><USER18> Thanks for the recommendation. We do have some screenshots on the features page. Ideally next iteration will have more focus on the screenshots. Much of our design is changing at the moment while in beta.

</comment></comment></comment><comment><USER20> I worked for a company that used Request Tracker for this stuff. It worked for our purposes. I also used it in another context after that.

For the free software projects on the web I'm familiar with, many use Bugzilla to deal with issues and feature requests. Also popular, although a little less so, seems to be Trac. They are all over the web - [http://bugzilla.redhat.com](http://bugzilla.redhat.com) is one example for Bugzilla, [https://core.trac.wordpress.org/tickets/latest](https://core.trac.wordpress.org/tickets/latest) an example for Trac.

</comment><comment><USER21> Looking at some of those 'complex' management tasks it seems like a missing feature would be to poll your repositories to look for TODO: 's and list them.

For instance, I'm the sole developer of my web backend, iOS and android platformy thing and while android studio has good TODO: Integration sublime and Xcode require plugins, it would be awesome to have something that looks at all three repositories and tells me where i have scribbled a TODO: somewhere; or even just for comparing the different method names of my app across platforms -

Perhaps someone knows of some such tool already out there that does this?

<comment><USER22> Might not work for your development needs, but such a feature exists in PHPStorm/Webstorm, and I'm guessing probably all of the other IntelliJ products.

There is a 'TODO' tab that shows you all 'TODO's in your project directory. Like so: [http://i.imgur.com/TW4jXN8.png](http://i.imgur.com/TW4jXN8.png)

<comment><USER21> Yes, that's exactly what android studio has (to my understanding it's just a modified IntelliJ environment). But I want one that knows about all three Of my repositories (all of them relating to the same project). A global IDE, if you will. Or at least a global coordinator

</comment></comment></comment><comment><USER23> I concur with dangrossman, you need to think through your process & systems.

<comment><USER24> Yup, seconding this. You can't implement a solution without thoroughly understanding what the problem is. Also, be sure you're looping in everyone who would be working with the new system at some point to get their thoughts and feedback- after all, if they have to use the system every day you want to make sure it actually helps instead of hinders them!

</comment></comment><comment><USER25> We use Trello with a slack integration on certain boards.

</comment><comment><USER26> The search for a perfect todo, project management app and bug tracker is the perfect distraction. I think what we want the most is the ability to schedule and forget about it until the time it's ready to be done. I've used Todoist, Trello, MantisBT, my own home made todo list and a dozen others. Nothing ever beats pen and paper or just a good review. I'd say Trello, Todoist and a good bug tracker are enough for any small team. Larger teams, I can't speak for.

</comment><comment><USER27> Imho Jira is one of the best tools voor large projects. From brainstorming to development to support. But maybe it feels too old because it can be difficult to setup?

</comment><comment><USER28> Something simple like Wunderlist or Asana is a good choice, IMO. The less time you spend dealing with your PM tool, the more time you can spend on actually doing important things.

I've also heard this argument if you're running a product, though I'm not sure how on board I am with it: don't record user requests. The important ones will be requested enough that you'll remember it.

<comment><USER29> The important ones do keep making it to the top - it's important to have the pattern recognition and telling others that even though we're saying "not now" for a feature...that can change if it comes up more and more often. The hard part is that people don't tell you when the issue occurs again because they "know you already said no to that..." It's a tough line to follow.

I direct all feature requests go on a list that CS owns and we review it with our customer team, vp eng, myself and qa in a weekly meeting. We talk about the problems, get shared understanding and we collectively agree if we can say "not now". "Worth looking into". "This is easy let's do it now". "This could be tough or easy - needs more info". This is basically what partly feeds a short backlog (~20 items) that gets prioritized during sprint planning. Plus longer term roadmap stories.

Roadmap - a ppt with: Next 3 months (most detail) Next quarter (high level, use cases identified) Next Half (broad themes)

</comment></comment><comment><USER30> I use GitHub issues and labels. Every issue starts out with a backlog label, when I pull it off the backlog, I assign it to a team member, add in-progress label, and the assigned member will go through it and apply an estimate label saying how long they think it'll take to do. When they're finished, they'll submit a pull request mentioning the issue, and apply a spent label signifying how long it actually took them.

All issues also get scope and type labels. Type signifying bug, feature, hotfix, etc. Scope saying what piece of the software it's for.

We also use milestones for releases. Each release gets a codename, and that codename is used for the milestone and all backlog and in-progress issues are applied to the release it's meant for.

Right now there's no UI for anything, but we're building internal tools that create a visual of this whole system for us.

</comment><comment><USER31> Sounds like you need a general project management system? I would give basecamp a go, if your needs are simple. If your needs are simpler, a text document is great and can take you fairly far. It works for a lot of people and use cases.

Most of the time, as a dev working on a client codebase, i do just fine with github issues.

But for everything else, if you're like me and have a lot of different things to capture and track, I haven't found anything that cuts it. So I'm close to launching a data platform for when you want to have your own workflows, analytics, monitoring and reporting of... anything. So you could use it to get an email every day of your open todos, or to nag you until you workout, or just simply act as a place to keep bits of information.

</comment><comment><USER32> I use Things for my todo list. Been using it for years and once you get the flow down it's amazing.

<comment><USER33> Things is the perfect midpoint between a simple todo list and a complex, overwhelming GTD-like system. You can easily use it however you want, and the iPhone syncing is great.

</comment></comment><comment><USER34> I use and highly recommend Fossil ([http://www.fossil- scm.org](http://www.fossil-scm.org)). It can handle each of your main purposes out of the box with ease.

It's got a good command line interface, a built-in web interface, it's self- contained, and the model is easy to understand. It's simple enough that I can use it as a replacement for RCS for personal stuff (like a LaTeX document) but it scales to large projects too (it's used by SQLite and Tcl/Tk, for example).

It's also trustworthy, with a solid, portable, and well-tested code base—not a surprise since it was originally authored by D. Richard Hipp. I have no clue why it isn't more popular.

<comment><USER35> Yeah, there doesn't seem to be all that much discussion about fossil compared to a few years ago. It is clunky in spots (e.g. the command line interface to tickets), though its a pretty interesting option.

</comment></comment><comment><USER36> I will highly recommend Redmine. Using it for almost 2 years and love it. It has pretty much all the features of Jira but absolutely free of cost. [http://www.redmine.org/](http://www.redmine.org/)

</comment><comment><USER37> We've been using Taiga[0] recently. It's pretty nice, and free for now. I'm a big fan of how easy it is to loop it into our workflow.

[0]: [https://taiga.io/](https://taiga.io/)

</comment><comment><USER7> I use JIRA for my day work and GitHub Issues for my open-source projects.

I'm a long-term JIRA user (and even somewhat evangelist). There are probably many much more "modern" issue trackers over there, but JIRA worked extremely well for me for many years. There are a few big problems with JIRA, though (field-level security and limited issue hierarchy).

For my OS-projects I've found GitHub issues to be more than sufficient. That's what I'd call clean and simple.

</comment><comment><USER38> We are a bit bigger (150 people or so, so take this with a grain of salt).

We use Zendesk to track bugs. It's nice because of its assignment features. That said, I find it terrible about everything else.

Feature requests are currently in UserVoice, however we're about to move over to Aha.io instead as we use that for product roadmapping and it's easier to move a request right into the plan and then push into rally (we use rally instead of jira for sprint planning)

</comment><comment><USER39> Our team uses Thoughtworks Mingle ([https://www.thoughtworks.com/mingle/](https://www.thoughtworks.com/mingle/)) Its got a simple, rich interface and is free for a 5 user team. You can create your own card walls and track features/bugs/to-do items with different types of cards. Works really well for Agile teams.

</comment><comment><USER40> Excel sheet on office online. Urgent tasks go on the top left. Quick tasks go up.

Microsoft Outlook contacts: put the word todo in the comments field. Any notes also in comments. Everything is searchable. Common items come up together on search by keywords.

A todo folder in the file system full of text files backed by a Git repository. This is kind of the equivalent of microsoft outlook contacts for me.

Flags on emails.

</comment><comment><USER41> Trello + Slack + Github. 1\. Github to track issues, INTEGRATE it with Slack. 2\. Trello for your agile board, INTEGRATE it with Slack. 3\. If might also be a good idea to write code that emails and sends a text message to all the mobile phones of your developer.

Using those tools felt like a breath of fresh air. They have a mobile app and web app that has an amazing UI/UX.

</comment><comment><USER42> I use LiquidPlanner because of 1) ordinal prioritization 2) confidence interval based estimates 3) easy to track project status 4) easy to review developer workload

More details in [http://xn.pinkhamster.net/download/New_Process_and_Tools.pdf](http://xn.pinkhamster.net/download/New_Process_and_Tools.pdf)

</comment><comment><USER43> //TODO: fix this thing below here

Been mulling around making a vim plugin like vim-flake to put the todos into the quickfix window on :w

<comment><USER44> I use this feature in Eclipse. A GitHub plugin would also be cool (i.e., open an issue when a new todo appears; close it when it's removed).

</comment></comment><comment><USER45> I like to use [https://kanbanflow.com/](https://kanbanflow.com/)

It takes the usual kanban approach that Jira and Trello use, but is contained in a no-nonsense html5 friendly, mobile friendly website. No complaints, free to start, and premium features aren't costly if you need them.

</comment><comment><USER46> Iron out your process. Use free tools that make it easy to export your data if it doesn't work.

Trello (other kanban tools) - very flexible. Gitlab. Free, open-source, host it yourself.

Jira is a powerful tool, it's also very complicated and expensive. You don't want to blindly jump into that commitment.

</comment><comment><USER47> [http://ifdefined.com/bugtrackernet.html](http://ifdefined.com/bugtrackernet.html)

has just enough fields, features, and customization to be useful but not overwhelming.

</comment><comment><USER48> I use Trello for my side-project.

I like putting the tasks into the the different columns so I have a Ideas, Open, In-Progress, Shipped.

Yes, I like Trello but sometimes I forget about it and yeah life.

</comment><comment><USER49> We're using Usersnap and it works great for larger projects. With a easy to use filtering / tagging & searching features it simple to find certain bug reports.

</comment><comment><USER50> As a sole developper, I use TodoList from AbstractSpoon I am totally addicted to it.

For a team, it's probably not what you need though.

</comment><comment><AUTHOR> Thanks for all of the feedback and responses. This is helpful—and I have some reading to do. :-)

</comment><comment><USER51> I've used Wrike a lot on bigger teams, works great. Not a fan of Asana.

</comment><comment><USER52> We use redmine for development ticket tracking and basecamp client side.

</comment><comment><USER53> Zenhub (integrates with github), Bugsnag.

</comment><comment><USER54> sticky notes!</comment>


Bernie Sanders rivals Clinton in fundraising - <AUTHOR> http://www.nytimes.com/2015/10/02/us/politics/bernie-sanders-election-campaign.html <comment><USER2> The Democratic Party is showing its true colors in their handling of Sanders and their ridiculous debate schedule.

By all measures, Sanders is a REAL candidate. He's got more support and more money than most of the jokers on the Republican side who are getting respectful treatment from their party and the press.

Yet Debbie Wasserman Schultz and other party insiders are doing their best to exclude the IA/NH front-runner from getting his message out to Democratic voters.

<comment><USER3> > He's got more support and more money than most of the jokers on the > Republican side who are getting respectful treatment from their party and > the press.

This doesn't mean much in itself. He's one of three candidates, compared to ~15 Republican candidates. It's almost mathematically certain that two of the three Democratic candidates will have more support that 'most of' the Republicans, regardless of their ideology.

It would be meaningful if he _didn 't_ have that level of support, given that there are only two other choices (and that practically nobody has even heard of one of the other two).

<comment><USER4> > He's one of three candidates

Pretty sure that's _six_ declared candidates: Clinton, Sanders, O'Malley, Chaffee, Webb and Lessig.

</comment></comment></comment><comment><USER5> Nobody wants to see or hear from Hillary Clinton. It is hard to run for President like that, regardless of the Democratic Party's nod that it is her turn. They decided that is was John Kerry's turn and we got four more years of Bush.</comment>


Faecal transplant effectively treats recurrent or unresponsive Clostridium diff - <AUTHOR> https://discover.dc.nihr.ac.uk/portal/article?id=SIG-5000506&utm_content=buffere8198&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer <comment><USER2> I have had C Diff. It is extraordinarily unpleasant. In addition to the normal symptoms it also came with extreme fatigue and a weird sense of doom about the future. The antibiotics need to be taken every 6 hours (limiting your ability to sleep) and gave me really creepy dreams. Being stuck with recurrent C Diff sounds miserable and I'm so glad that people in that position have a way out

<comment><USER3> I don't want to make you relive the dreams, but can you elaborate on "creepy"?

<comment><USER4> Think of the most weird fever dream you've had and that is probably similar.

I think one of the stranger fever dream I've had was sometime in college when I was learning about complex numbers, the red standby LED on the TV in my room seemed to be a portal into the complex plane one feverish night.

Having also tried a number psychedelics, fever dreams do have quite a different quality to them.

</comment></comment></comment><comment><USER5> Throwaway account -- I had recurrant c-diff for the better part of 2 years. For a while I had accepted that I would just be taking Vancomycin for the rest of my life. Thankfully I was able to get into a study at the U of Minnesota doing transplants. The first one didn't 'stick' and the c-diff repopulated within 6 months, but after the second one I've been clear of it. Horrible stuff. Worsened my Crohn's disease by a large amount.

</comment><comment><USER6> Ancient Chinese yellow soup!

[https://en.wikipedia.org/wiki/Fecal_microbiota_transplant#Hi...](https://en.wikipedia.org/wiki/Fecal_microbiota_transplant#History)

Orally administered, too.

</comment><comment><USER7> Fluoroquinolone antibiotics (cipro, levaquin, etc) are dangerous and horrific, and irreversibly destroy gut bacteria. This article is about fluoroquinolones, which are well documented to _cause_ C.Diff infections because they destroy most gut bacteria _except_ C.Diff, allowing it to overrun.

</comment><comment><USER8> I wonder to what extent is Obesity contagious. If you can improve your gut bacteria, surely you can make it worse. Can you pick up gut bacteria from Obese people. Maybe going to the gym helps you lose weight because you touch surfaces and pick up bacteria from fit people. And so on. Just conjecture.

<comment><USER9> I don't think obesity itself is contagious (unless you're mucking about in an obese person's fecal matter). My hunch is antibiotic usage disrupts your gut biome enough that it pushes your energy extraction balance off, causing obesity.

As a society, we abuse antibiotics in the aggregate (demanding it from health care providers and pouring it into factory farms). It can't possibly not be disrupting our guy biome.

It also doesn't help that the sugar lobby/industry is so powerful, and sugar/corn syrup is in everything.

<comment><USER10> I don't think it's the energy extraction that's changing, but people's set points for weight.

> It also doesn't help that the sugar lobby/industry is so powerful, and > sugar/corn syrup is in everything.

Corn syrup ain't good, but we have fat people in other parts of the world, too.

<comment><USER9> Rapidly increasing obesity rates seem to be associated with a first world/western diet.

<comment><USER10> Further investigation seems useful.

Eg anecdotally I can see people in India putting on the pounds much more than Chinese---whether on the mainland or in South-East Asia like Singapore. But I don't know the statistics off the top of my head, I only lived there.

</comment></comment></comment></comment></comment><comment><USER11> _After initial "cure" of Clostridium difficile with antibiotics, about 15-25% of patients develop a recurrence within a few days to several months. The chance of a recurrence depends in large part on the type of antibiotic being taken, such as Flagyl, Vanco, or Dificid, as well as the age of the patient.

This repeat infection can keep on recurring, even after multiple courses of antibiotics. We have seen some unfortunate patients with 10 or more attacks of C. diff in a two-year period. It can lead to chronic diarrhea, weight loss, and diminished quality of life.

We think that recurrence of C. diff depends on a "Perfect Storm" of several factors:

1\. Simultaneous failure of the immune system with inadequate antibody formation

2\. Failure of the colonic flora to regenerate, owing to exposure to antibiotics.

Failure of the immune system to generate an antibody response is quite common after age 60. The older the patient, the weaker the response to an infection or to vaccination_

[http://cdiff.in30minutes.com/recurrent-c-diff-why-does-c- dif...](http://cdiff.in30minutes.com/recurrent-c-diff-why-does-c-diff- sometimes-keep-coming-back/)

</comment><comment><USER12> This is a super interesting topic but the cynical side of me thinks it doesn't get enough attention because you can't patent bacteria(?)..

For more on this, checkout the work of Martin Blaser

[https://www.youtube.com/watch?v=KwK_O0ahDKo&t=168](https://www.youtube.com/watch?v=KwK_O0ahDKo&t=168)

</comment><comment><USER13> I new someone with serious repetitive (daily) diarrhea. Not treatment helped and it lasted for years. Doctors had no solution. Don't know if it was Clostridium Difficile. It started after taking a medication.

One day, a solution was found on Internet. It was to eat cheese made with raw milk. After three months eating various cheese with raw milk every day, the person had no more diarrhea. This has to be done in country with strict health control on cheese production.

<comment><USER14> Drinking Kefir is easier and better.

</comment></comment><comment><USER15> I know two people who had serious problems for many years and recovered after doing fecal transplants. Placebo or not, I would recommend it to people who can't be helped by regular medicine. Certainly worth a try.

</comment><comment><USER16> There seems to be a correlation between gut balance and lifespan, in animal models, [1]. I wonder if a suitable fecal transplant could (somehow) promote longevity.

[1] [https://www.sciencedaily.com/releases/2014/01/140116130646.h...](https://www.sciencedaily.com/releases/2014/01/140116130646.htm)

</comment><comment><USER17> I recall reading a similar clinical trial involving bacterial vaginosis. In BV, vaginal bacteria are imbalanced and thus it was hypothesized that transplanting healthy flora would be helpful.

</comment><comment><USER18> No it doesnt. Placebo controlled trials show it has no effect. Im surprised at the nhs for this shoddy review.

<comment><USER19> Here's a randomized trial with placebos that did work. I wasn't able to find one where it didn't work.

[http://annals.org/aim/article-abstract/2545886/effect- fecal-...](http://annals.org/aim/article-abstract/2545886/effect-fecal- microbiota-transplantation-recurrence-multiply-recurrent-clostridium- difficile-infection)

<comment><USER18> I submitted on a while back. Will check later if people reverse the downvotes and assume good faith.

<comment><USER20> You'll provide evidence for your claims if people down downvote you for making claims without evidence?

I'm not terribly impressed by that approach.

<comment><USER18> In my world people ask politely for refs or search for it themselves, rather than downvoting first (which is saying "your comment isn't worth reading").

I got up out of bed, posted a comment and was going to look for the link later if people asked. (I did a quick search and didn't find it). However, from the comments here, it's pretty clear people aren't interested in the science. Carry on...</comment></comment></comment></comment></comment>


Programming a space invader in OCaml and OpenGL: lessons learned - <AUTHOR> https://marmelab.com/blog/2020/02/21/ocaml-and-opengl-in-practice.html <comment><USER2> ReasonML is just an alternative syntax for OCaml. Often people use "ReasonML" shorthand for "ReasonML, converted to OCaml, compiled to Javascript with BuckleScript" and "OCaml" for "OCaml compiled natively" but it's perfectly possible (and actually really easy) to use OCaml with BuckleScript and Reason natively.

Also note that despite the "O" in the name, OOP in OCaml is rare (for instance, there isn't any in the code in the article).

<comment><USER3> What's the state of using Reason natively? Last time I checked all the documentation and examples where towards the reason/js/react ecosystem. Are there any good native code projects written in Reason to look at for reference?

<comment><USER2> People don't do it much, but if you're using the most popular build system (dune) you can replace your .ml files with .re ones and it will Just Work. So you can use OCaml projects for reference (I think anyone who's doing Reason should have a vague grasp of OCaml syntax, it's not really that different).

<comment><USER4> > I think anyone who's doing Reason should have a vague grasp of OCaml syntax, > it's not really that different

Especially if you're targeting native, so all your dependencies are written and documented in OCaml syntax.

</comment></comment></comment></comment><comment><USER5> > it is very complicated to install the base stack to develop in OCaml

I'm not sure why the author decided to use such a complicated setup using Make and Docker.

They could have just ran `opam switch create 4.09.0`, which would have created the compiler, then `opam install ...` for the dependencies.

Still, an interesting article. I wouldn't recommending using OCaml/ReasonML for gamedev since getting it to work with Windows is pretty much impossible.

<comment><USER6> It is complicated to figure out a straightforward way to do builds in OCaml. If you're not tapped into the Current Way, you kind of have to read this blog, read that fragment, piece it together. I worked it through for a project of mine, and it was unusually unpleasant vs, say, Haskell.

Docker because, presumably, he didn't want to dink with installing it locally.

<comment><USER7> > It is complicated to figure out a straightforward way to do builds in OCaml

Sorry, what is not straightforward in building with `dune`?

<comment><USER8> Some things I ran into:

\- How do I run tests? Oh, you can't really dune runtest on executables, only libraries. So how do I run tests on executables? Make a library with the core of the functionality and wrap it, I guess. Wasn't obvious.

\- Tree-like heirarchy of dune files confused me since it wasn't really explained anywhere. I wanted my source files in a `src` directory; most of the examples assume your `dune` file is just hanging out with the source in the toplevel.

\- Does `dune` handle dependencies (like I would declare them in a rebar.config, mix.exs, or a package.json)? Not really, it plays with opam, requiring one to read a bunch of docs for opam, and its files, and where they should go.

\- The syntax of the dune files changed a bit from when I started the project (it was just moving from jbuilder -> dune). Less of an issue now, though I still question the use of s-expressions.

\- Can I load an interactive shell with the definitions? There's a command in the documentation for it, but it didn't work quite right when I tried.

\- If you look at other projects, you'll see they use opam files differently from one another.

\- How do I add a dependency in my current switch (something like npm --save install <library>?) I tried `opam install --deps-only`, but it complained sometimes about the state of uncommitted files.

I understand why it's like this (trying to tie together a ton of use cases) and love developing in it after it's all said and done, but there are a lot of rakes to step on.

<comment><USER7> > Tree-like heirarchy of dune files confused me since it wasn't really > explained anywhere.

It's explained in project layout [1]. And it's not a tree like, it's basically flat, since it doesn't matter how deep in the file system your dune file is buried.

It's like `meson` in its concept.

> Does `dune` handle dependencies

It doesn't, and so neither do `meson`, `cmake` and most other build systems. As you may want to use various ways of installing dependencies: native packages, manual compilation, opam, esy.

> Can I load an interactive shell with the definitions?

Yes, you can run `dune utop ./path`

> If you look at other projects, you'll see they use opam files differently > from one another.

Dune is independent of opam, opam file is needed to publish your package to opam. You can specify packages with dune without creating an opam file, see [2]

> I tried `opam install --deps-only`, but it complained sometimes about the > state of uncommitted files.

If you use opam, you can do `opam install --deps-only`, or `dune build @install`, which would suggest a command to install missing packages.

[1] [https://dune.readthedocs.io/en/stable/overview.html#project-...](https://dune.readthedocs.io/en/stable/overview.html#project- layout)

[2] [https://dune.readthedocs.io/en/stable/concepts.html#package-...](https://dune.readthedocs.io/en/stable/concepts.html#package- specification)

</comment></comment></comment></comment></comment><comment><USER9> The underlying OCaml naturally.

Having learned ML via Objective Caml's predecessor, Caml Light, ReasonML seems to be just sugar coating for those with aversion to ML classical syntax.

<comment><USER10> > ReasonML seems to be just sugar coating

That's exactly what it is, no secret about that, that's the goal of that project.

<comment><USER9> Which begs the question why not learn the real deal, instead of adding another layer to debug.

Programing isn't poetry.

<comment><USER11> I disagree, code is for and by humans. There are likely very real runtime consequences to having code that is "ugly", because the next human to touch it will value it less and do a suboptimal job.

Of course all of this is highly subjective, but my understanding is that it's important to consider if you want highly successful projects.

<comment><USER12> > code is for and by humans

I think this is very much domain dependent. Generally the more important efficiency is, the less I find this to be true. And really, code is always for the machine at the end of the day.

Additionally, if an added code layer makes the code more difficult to debug, that's also making the code worse for humans. Note I'm not arguing for or against whether that's happening in the case of OCaml/ReasonML, just making the point.

<comment><USER13> > code is always for the machine at the end of the day

On the other hand, code is read much more than it is written.

You may also regard efficiency as a necessary evil if the cost is readability.

Ultimately the winning strategy in this regard is achieving "free abstraction", making code that is both readable and efficient. Different languages aim at this. C++ has been best at this for most of history. Haskell and Rust are competing at this now as well.

OCaml isn't exactly efficient because of free abstraction, but because of its extremely simple translation strategies. OCaml's "flambda" compiler extension wasn't released as stable until 4.03 (2016), which means that before that, very little high-level transformation was happening.

My experience is that OCaml programmers care about low-level optimization, for good and for bad.

For example, in this StackOverflow response there are two examples of a function 'partialsums':

[https://stackoverflow.com/questions/37694313/make-ocaml- func...](https://stackoverflow.com/questions/37694313/make-ocaml-function- polymorphic-for-int-lists-and-float-lists/37710287#37710287)

The one that Jeffrey Scofield provides is essentially more efficient because the accumulated value is a list, just like the end result, whereas my solution accumulates a tuple, which means every iteration of the fold involves boxing and unboxing that tuple. An optimizing compiler working at a higher level of abstraction might figure that out and re-use the memory of the tuple, but no sir.

</comment></comment></comment></comment></comment></comment><comment><USER14> ReasonML is adversely affected by it's Ocaml base if anything. StandardML would have been a much better base (they went with Ocaml because it was a lower-effort to implement and Facebook has a lot of Ocaml devs).

The first bad part is that Ocaml _does not_ have a language spec. The implementation is the spec. This puts them at the whim of the Ocaml devs with no other options. SML is a standard with several good implementations.

Ocaml requires different operators for float and integer arithmetic. SML assumes an integer type unless you include a decimal. Both need to be replaced with module typeclasses (and both are working in that direction). For SML though, your existing code can continue to just work as it did before while Ocaml will be left with lots of `+.` or `*.` operators everywhere.

Another mistake that bleeds through is mutable strings. This is an outgrowth of all arrays being mutable. Immutable strings allow efficient representation as ropes instead of normal arrays (along with other optimizations that are good for GC'd languages). SML has immutable strings and vectors along with arrays (which you can still use as mutable strings of characters if you need them).

For their React-like goal though, Ocaml's lack of anonymous record types is the absolute worst. In SML, I can just type up a record and pass it in (no type definitions required). When passing in stuff to a component, you have to have all these named arguments. In SML, I'd just pass an anonymous record and destructure it in the function -- Just like in Javascript, but with types behind the scenes to keep everything straight.

Writing a custom parser for Babel like typescript or coffeescript have done would have been better for the language design and independence.

<comment><USER15> FYI strings are now immutable in OCaml. It was a compiler option starting with 4.02 and it has become enabled by default since 4.06.

<comment><USER14> That's nice to know. On the flip side, that's not nice for interaction between older code that wants to mutate and newer code that wants to "copy". If the "copy" code is actually copying all the time behind the scenes (something it has to do if you are compiling with mutable strings for backward compatibility with the rest of your codebase), that's a huge performance hit.

</comment></comment></comment><comment><USER16> I am confused by this article. It went an entirely different direction based on the question proposed. It was all entertaining, nonetheless, but besides some passing comments to Reason's documentation being better, the question does not seem to be explored much by this article. It's a good article and should be renamed to maybe "Getting started with OCaml and OpenGL"

<comment><AUTHOR> You're absolutely right. I wanted to justify my exploration by way of comparison between ReasonML and Ocaml.

The title ("Programming A Space Invader In OCaml and OpenGL: Lessons Learned") still fits with the content, don't you think?

<comment><USER16> I see that now, yes I do. I think maybe the headings and subheadings are also throwing me off as well. I wasn't sure if I was reading one of those types of blogs that have a continuous feed of articles on one page.

</comment></comment></comment><comment><USER17> Marmelab makes the pretty awesome react-admin library for autogenerating admin interfaces:

[https://github.com/marmelab/react-admin](https://github.com/marmelab/react- admin)

I'd love to see an official Marmelab adapter so I can build my admin interfaces with ReasonML.

<comment><USER18> We already have hard time migrating it to TypeScript :p How such an adapter might work?

</comment></comment><comment><USER7> > I choose a more undisclosed tool (obuild) because of its simplicity and its > _brief documentation_

> And although some tools exist to make our life easier, they are _poorly > documented_

Seems like author choose something poorly documented. Dune build system [1], opam [2] and esy [3] package managers are very well documented.

[1] [https://dune.readthedocs.io/en/stable/](https://dune.readthedocs.io/en/stable/)

[2] [https://opam.ocaml.org/doc/](https://opam.ocaml.org/doc/)

[3] [https://esy.sh/docs/en/what-why.html](https://esy.sh/docs/en/what- why.html)

</comment><comment><USER19> This article title and conclusions are misleading. It shows how to write a simple game in OCaml and then proceeds to conclude that ReasonML is better. I would expect the author to have the same game implemented in ReasonML for comparison to show us why. Otherwise, it is not very convincing.

<comment><USER20> having done some OCaml and F#, where F#'s syntax is more like reason, i think it is pretty clear that OCaml is a fascinating language but what does impose some weird syntactic work that both reason and f# relieve you of. probably to someone sufficiently used to ocaml it doesn't matter but it can hurt adoption

<comment> nv-vn I don't see how you can say F#'s syntax is more like Reason. OCaml and F# have nearly identical syntax for the core language, with the few differences being:

1) places features diverged

2) modules

3) F#'s "light" syntax mode

None of these really seem like Reason at all. Do you have any specific places where they're similar?

</comment></comment></comment><comment><USER21>
        dnf install ocaml ocaml-lablgl-devel

?

Anyway here's a toy game I wrote in GL + ODE + OCaml years ago: [https://github.com/fccm/OCamlODE/blob/master/examples/katama...](https://github.com/fccm/OCamlODE/blob/master/examples/katamari.ml)

</comment><comment><USER22> Interesting but why talking at the end about F#, Scala and not Haskell (general-purpose, statically typed, purely functional programming language with type inference and lazy evaluation) wish is more old and mature than OCaml and F#: \- Haskell: 1990 \- F#: 2005 \- Scala: 2004

</comment><comment><USER23> Between reasonml and elm which one should I pick?

<comment><USER24> If you've not used an ML before, start with Elm.

Once you feel you have that sussed - it shouldn't take too long - pull up ReasonML and give it a go. Use the Bucklscript-Tea library - the architecture will be familiar from Elm.

Then give Reason-React a go.

Once that itch has been scratched move on to PureScript for a whole new rabbit hole to fall down.

<comment><USER23> I mean I'm familiar with ml and haskell, I'm more interested in what's the best platform for building things. The language itself is only a part of the equation.

<comment><USER25> I believe Reason is more practical (easier FFI), but as for building things, at this point it's probably Typescript :-)

Reason still hasn't had its async story ironed out, and has poor support for Unicode[0]

[0] "ReasonML strings are encoded as UTF-8 and not compatible with JavaScript's UTF-16 strings" (from [https://2ality.com/2017/12/basic-types- reasonml.html](https://2ality.com/2017/12/basic-types-reasonml.html))

<comment><USER26> > Reason still hasn't had its async story ironed out,

Reason's async story is pretty simple: use promises until the let-syntax (like generalized do-notation) lands, then use that.

> "ReasonML strings are encoded as UTF-8 and not compatible with JavaScript's > UTF-16 strings"

Unfortunately this is inaccurate, and you left out a significant detail from the article. Let's go point by point here:

\- Reason strings are not encoded as UTF-8, in fact they aren't encoded at all.

\- But, when targeting JavaScript using the BuckleScript compiler, strings can contain Unicode characters and use the JavaScript runtime's support for Unicode.

\- This is not a short-term workaround, but the intended solution.

</comment></comment></comment></comment></comment><comment><USER27> >Even though it is known for its robustness and its large standard library

I thought the ocaml stdlib was relatively small though?</comment>


Web Design Trend: Single-Page Websites that Work - <AUTHOR> http://www.queness.com/post/13492/web-design-trend-single-page-websites-that-work

<comment><AUTHOR> I did not feel like some of the examples were single-page sites, but the examples are really good.

As a coder, these definitely help in thinking critically about what can/should be done, and inspire ideas for design.

I am curious to see other interesting examples.</comment>


Ask HN: How do I write a userscript? - <AUTHOR>

I just want to add a simple userscript to apply some CSS for a fluid browser. Searching on Google didn't turn up much as far as step by step tutorials are concerned.<p>Thanks. <comment><USER2> <http://diveintogreasemonkey.org/> suggests <http://wiki.greasespot.net/> which has a Tutorials section: <http://wiki.greasespot.net/Tutorials>

Browsing <http://userscripts.org/> and finding something similar may also be useful.</comment>


Should Apple sell the iPhone at Wal-Mart? - <AUTHOR> http://www.alleyinsider.com/2008/11/iphone-to-wal-mart-sure-why-not-aapl-

<comment><USER2> Interesting as both Apple and Wal-Mart strong arm their 'partners' into lowering prices (major labels on iTunes/Wal-Mart's suppliers)

I'd love to see a meeting/match between Jobs and whoever negotiates for Wal- Mart. If only to see Steve get his ass handed to him.</comment>


Ask.com brings back Jeeves in the UK. I'd love to see him here, too. - <AUTHOR> http://technologizer.com/2009/04/19/the-return-of-jeeves/

<comment><USER2> fluff articles by someone who doesn't contribute ANY comments: 210 submissions linking to his website vs 2 comments.

Flagged!</comment>


Thinking Of Quitting? Remember the sun will rise - <AUTHOR> http://www.tryary.com/news/398/thinking-of-quitting-remember

<comment><AUTHOR> Has anyone thought of quitting before, but didn't give up?</comment>


The Startup Con Man - <AUTHOR> http://www.businessinsider.com/the-startup-con-man-2010-6

<comment><USER2> DinglePharb? Are you fucking kidding me? Anyone who believes that a company named DINGLEPHARB is successful deserves to be conned. Further proof that a fool and his money are easily separated.</comment>


Woman Drank Herself to Death with Coca-Cola - <AUTHOR> http://news.discovery.com/human/health/deadly-coca-cola-habit-130212.htm#mkcpgn=rssnws1

<comment><USER2> > Crerar said the family had not considered her Coke habit dangerous because > the drink did not carry any health warnings.

What!? Are people really that dense? 2.2 gallons a day is, for the average person, a ridiculous amount of any beverage, even water. Assuming it's not diet Coke (which has its own set of problems) that's 1760kcal/day, 475g/day of sugar, on top of the 400mg/day of caffeine. It seems like a no-brainer that this would slowly kill you. It would just be a question of what got you first - the caffeine or the type II diabetes.

</comment><comment><AUTHOR> I know this sounds like an item more suited to Reddit, but given the Mountain Dew and Red Bull diets of some, this might be relevant.</comment>


Basis of the undermining effect of monetary reward on intrinsic motivation - <AUTHOR> http://www.pnas.org/content/early/2010/11/05/1013305107.abstract

<comment><USER2> I've read other studies that say the same, and even experienced the effects myself. If I'm doing something for fun or the love of it or out of kindness, and you offer me money to do it, I lose a LOT of motivation. Sometimes even to the point that I don't do any of it.

I think a lot of people have trouble realizing that money isn't the only form of payment for something. Gratitude or self-respect can be even more powerful, especially in an absence of them.</comment>


Software Development and the Sunk Cost Fallacy (2010) - <AUTHOR> http://www.skorks.com/2010/04/software-development-and-the-sunk-cost-fallacy/ <comment><USER2> Previous discussion: [http://news.ycombinator.com/item?id=1318809](http://news.ycombinator.com/item?id=1318809)</comment>


IBM Watson Health slashes workforce - <AUTHOR> https://www.massdevice.com/report-ibm-watson-health-slashes-workforce/ <comment><USER2> I'm an MD, and I dabble in programming and AI/DL. While I don't really care much about Watson in particular, the pervasiveness of the "enter healthcare = death" equation is worrisome to me. And it should worry you, too.

There's a lot of potential for good applications of this type of tech in healthcare, but the barriers to actually getting it off the ground strangle it in the crib.

<comment><USER3> I work for a medical software company which evaluated Watson for use in our diagnostic product.

It should be seen as a Good Thing that medical is a Serious Field where Non- Serious Ideas get run through the ringer and fail.

And that's what happened with Watson.

The word from our engineers was that Watson was designed to sell commercials, not be a useful tool in a problem space like differential diagnosis or drug reactions.

I think this is good. Financial has the same reputation. You can't just use agile to bust out a minimum viable medical or financial product. You will be chewed up and spit out. And rightfully so. Because when it comes to our health, or our money and our investments, we don't have tolerance for failure.

OK, my social network double posted my communication, annoying but it's just a communication. However "my financial tool just double posted a transaction", or "my prescriptions tool just doubled the dose of a medicine" \-- these are not OK states at all.

I wish Watson lived up to the hype, but sadly, our experience was that it does not. So it failing out of Healthcare isn't a surprise to us, nor is it a bad thing.

<comment><USER4> Tangentially related: how does one get their foot in the door at a medical software company? Is there a big market for such professionals?

<comment><USER5> Learn MUMPS and move to Wisconsin.

<comment><USER6> Is MUMPS still a thing :-) maybe I ought to dust of my RT-11 / FORTRAN skills off

<comment><USER7> The biggest EMR company was Epic and uses Mumps [0]. However, they are losing share to Center and others [1], so this formula will only work for a little while longer.

[0] [https://news.ycombinator.com/item?id=13860937](https://news.ycombinator.com/item?id=13860937)

[1] [https://ehrintelligence.com/news/cerner-epic-mckesson- among-...](https://ehrintelligence.com/news/cerner-epic-mckesson-among- top-5-global-health-it-vendors)

<comment><USER8> Epic still dominates the EHR space.

They have deployments slotted for 3 years.

If you have ever worked with epic, they offer "managed" solutions, which you either do the epic designed way, or don't go epic... They have enough market share and business to dictate how things will work in a hospital env

</comment></comment></comment></comment></comment></comment></comment><comment><USER9> IBM is a confusing one. For a while I was getting IBM powered blockchain ads coming through my Instagram feed, and I seem to remember stopping by their booth at Dreamforce a few years ago where Watson would help determine what candy they'd give you (or something like that). One thing I'd be interested to know is what they actually _do_ vs. the marketing spin of what they do.

<comment><USER10> I also used to work for Watson. It remains one of the best jobs I've had. There's a number of useful services available through Watson on the IBM Cloud. I'm a little biased toward Watson Assistant which can be nicely customized and integrated with other solutions to create some terrific customized virtual agents. You can also easily train natural language systems using Knowledge Studio.

</comment></comment><comment><USER11> Very sad for long time IBMers. But Is it the beginning of the much controversial AI Winter revival ?

<comment><USER12> It seems Watson was founded on the false premise that lots of hand coded things could be called an "AI". It's the victim of its own winter, because it was never going to live up to its own hype.

<comment><USER13> Do you imagine that other, more successful "AI" services from large companies do _not_ involve a lot of hand-coded things?

<comment><USER14> Yes. Well, at the very least, they don't involve _only_ hand-coded things.

</comment></comment></comment></comment><comment><USER15> I was hired by an acquired Watson Health division a little over a year ago, and after seeing the very confusing story of how IBM expects to grow and strengthen these disparate companies, I'm not surprised. I'm also saddened that some of my former colleagues were among those laid off.

</comment><comment><USER16> IBM seems expert at stealth layoffs. Possibly to avoid lawsuits?

[https://www.propublica.org/article/federal-watchdog- launches...](https://www.propublica.org/article/federal-watchdog-launches- investigation-of-age-bias-at-ibm)

</comment><comment><USER17> Is there a full breakdown of scope anywhere? I know there have been major complaints about Watson Health before, but I still can't tell if this marks a retreat from the program, or just a harsher-than-usual instance of the sort of layoffs pretty common for acquisitions.

</comment><comment><USER18> > "The message was that there are about 7,000 people in Watson Health today > and this was a cost-cutting exercise. 90 days' notice with 30 days' > severance."

If accurate, that severance benefit is just shameful, and simply not good enough from a large corporation. Absolutely no excuse for that degree of unjustifiable, unmitigated greed to offer so little when possibly damaging lives, especially for older workers who may face IBM-like ageism elsewhere now too.

Hard fought career advice I've learned: _always negotiate adequate severance._

It should be a heck of a lot more than 1 month, even if you're a junior employee. Just turn down jobs if they won't give substantial severance agreements. Unless you're in dire straits & have to take the job. Otherwise, don't do it. That employer will not consider the impact that some surprise layoff has on you. Get it in writing, up front in the negotiation, and don't waste time with firms that won't offer it. Not worth it.

<comment><USER19> Severance packets is probably not an easy thing to negotiate when you are trying to sign an employment contract.

<comment><USER18> If it's a serious company, it's just an expected, standard part of negotiating, no different than salary, bonus, benefits, vacation, etc.

In general, you should ask if you'll be required to sign any NDA, non-compete, or non-disparagement agreements, either as part of a company handbook or as standalone documents. If so, the severance package should be commensurate with the duration and condition of those.

It is common to negotiate severance equal to your salary for the duration covered by the agreements, or at least a large fraction like 30-50% of the duration, so a competitive severance package would certainly be in the range of 4-6 _months_ of your base salary.

You can also negotiate to have company-paid insurance benefits extend past your termination date as part of severance, to avoid needing COBRA in the US.

The severance agreement should also cover anything like a company issued laptop, etc., if you are promised you can keep it after employment ends.

To get this, they'll likely require you to sign waivers to any additional monetary claims, and draconian IP, NDA, etc., agreements. And this is why you should force the issue of negotiating severance up front and why you should walk away from companies (like IBM) that won't negotiate.

Otherwise, they'll announce the restructuring or layoff and then hold you over a barrel, by claiming you have to honor their company policy non-compete anyway, and pressure you to sign restrictive documents at your HR exit meeting, generally offering some insultingly low severance benefit, like only a few weeks or months of pay and no continuation of benefits.

All of this advice is specifically for junior-level employees as well. Never let anyone treat you like you cannot negotiate severance just because you're a junior employee. Walk away from those companies.

For experienced employees, the amount of severance should absolutely be at least 6 months of pay and continued company-paid health coverage, and in many cases you can negotiate for it to fully match the duration of the non-compete or NDAs, usually 12 months.

Above all, don't accept any baloney nonsense about "standard policies" restricting severance to a small number of weeks of pay per each year of tenure, or any of that garbage.

That's just the standard line they feed to people who don't negotiate. And if a company refuses to be flexible on it, walk away.

<comment><USER20> I hear what you are saying, but feel like it also requires the caveat of "for in-demand roles where one has leverage in the negotiation."

At this point, a junior engineer _may_ have some of that, but I'm not sure you can really apply that to all levels of experience across all functions. I agree with the sentiment and logic behind it, I just am not sure that is actually something most people could consider.

</comment></comment></comment></comment><comment><USER21> Not surprising. Many "tech" companies enter the field with arrogance, thinking of course they can do health better. They unfortunately often have no comprehension of the regulatory regimes for the markets they enter and therefore the projects are doomed to failure before they start.

</comment><comment><USER22> No need for employees when Watson can do it all. Unbeknownst to these people, they renamed it Watson Health due to the fact Watson is going to run the entire division itself. Amazing! The future of AI is finally here! Watson has spent the last few years learning all these peoples' jobs.

<comment><USER23> This sort of sarcastic, content-free comment doesn't contribute much, and isn't a great fit for this community.

<comment><USER24> I disagree, I think it is satire showing the over-hyped nature of Watson and AI in general during this latest VC investment boom. HN still has room for humor

<comment><USER23> I agree that there's room for humor. But for that, it should be well-written satire that makes that point.

"[T]hey renamed it Watson Health due to the fact Watson is going to run the entire division itself" is a complete non-sequitur, just filling up space.

<comment><USER22> That's not what a non sequitur is.

Massive layoffs at a company that hypes its AI and is actually named after that same technology is called "irony", not non sequitur. I'm disappointed for having to explain this.

</comment></comment></comment></comment></comment><comment><USER25> I find the discussion relevant to Tesla's autopilot much?</comment>


Spiders float using electric fields - <AUTHOR> https://www.cell.com/current-biology/fulltext/S0960-9822(18)30693-6 <comment><USER2> Discussed yesterday...

[https://news.ycombinator.com/item?id=17465068](https://news.ycombinator.com/item?id=17465068)

[https://news.ycombinator.com/item?id=17467790](https://news.ycombinator.com/item?id=17467790)</comment>


JSON-Based Universal Messaging Format (2017) - <AUTHOR> https://github.com/cjus/umf <comment><USER2> > Note that there is a complex canonicalisation procedure for the JSON object, > and that the sender must mutate the signed object;

This is a big no-no and actual source of vulnerabilities. If you sign something, the signature goes _around_ what you want to sign.[1] Doing "in- line" signatures is excessively more complex and error-prone. The easiest and most secure scheme is actually "sign a blob of bytes", i.e. signing a packed representation of a message. That way, you get zero ambiguity issues as far as signature-content interactions go [2], and you don't actually need a canonicalized message representation any more (which is not a common feature of serialization formats outside ASN.1 encodings).

There might be other reasons to not use UMF, but this one is completely sufficient to avoid it.

(Also calling HMAC tags "signatures" is confusing as heck and should be avoided.)

(Also the actual method of how the MAC is calculated is not specified; so clearly UMF _is not_ a format, it is a meta-format.)

[1] Even JWT got that right.

[2] Context ambiguity AKA The Horton Principle remains, because that's not something a format solves.

<comment><USER3> Would you be able to elaborate on this?

Why is doing "in-line" signatures a worse design or a source of vulnerabilities? Are there any benefits for providing an in-line signature?

Any examples or additional information would be appreciated. Trying to better understand the issue at hand.

<comment><USER4> Option1: json.inlineSig: '{ "a": 1, "b": 2, "signature": "ff1341234..." }'

Option2: json.outOfBandSig: '?????'

Option2: json.signature: 'File=json.outOfBandSig; Signature=ff12341234...'

Basically if you try and do option #1 you actually need to parse the content, and _THEN_ find out it's untrusted (which means you need to _execute_ your parser on the potentially unknown / hostile bytes), and then pretend you never processed them in the first place (discard) unknown / hostile bytes.

If you do option #2 then you blindly process the bytes with the signature algorithm, verify they are trusted and THEN run your parser on bytes of a signed / known origin.

Compare:

signedParseInlineSig( '{ "a": 1, "signature": "<<INVALID>>" }' );

signedParseOutOfBandSig( '{ "a": 1 }', "<<INVALID>>" );

...with #1 you have to run isValid( input, JSON.parse(input).signature )

...with #2 you run isValid( input, signature ) && JSON.parse( input )

<comment><USER2> > Basically if you try and do option #1 you actually need to parse the > content, and THEN find out it's untrusted (which means you need to _execute_ > your parser on the potentially unknown / hostile bytes), and then pretend > you never processed them in the first place (discard) unknown / hostile > bytes.

And you need to remove the signature and reassemble the modified data structure back to bytes in EXACTLY the same way as the signer did. This is more work (for larger data structures) and way harder to get right.

Re-normalization of the message also has some other issues, e.g. you need to make sure that you are parsing and processing the re-assembled version (what the signature was checked against), _not the message you received_ ; otherwise your signature might be completely useless (think about an attacker inserting duplicate keys: the re-normalization might remove them, but your parser might normally not. Signature validates, but you're not processing what was signed! Oops.)

If you do this the best case scenario is that it kinda seems to work, and if you're lucky it's even secure, but it actually doesn't work or silently stops working for some messages after you update a parser somewhere in the system, because suddenly they disagree about some edge case, and your system breaks.

</comment></comment></comment></comment><comment><USER5> Maybe someone can comment, but I can't understand the value of this.

The meat of this proposal is the specification of the envelope. But it consists largely of things you would have to decide how to map to your application domain. Since there's no reason different apps would/could map these things the same way, there's no opportunity for interop created here.

I guess it ends up as an idea or example of how you might express a generic message in JSON. So that's of some use.

<comment><USER6> I agree. There is already a universal message format and it's called plain text. Wrapping that in JSON brings nothing to the table except very slightly slower parsing.

Web folks love JSON and rightly so, it solves many things in JS-land. It is not a useful message format if you are interested in high efficiency or small message sizes. In those cases fully binary messages are the way to go, of course.

If there were two things I would tell the web devs at my employer, they would be these: There is no universal message format that does not already exist, and web tech doesn't solve non-web problems better than non-web tech.

Bonus third thing: JavaScript rots your mind. Avoid it.

<comment><USER7> > _Bonus third thing: JavaScript rots your mind. Avoid it._

Could you elaborate on your hyperbole? What exactly "rots the brain"? Is Javascript deficient in some fundamental way that irritates you? Or do you merely object to its 20-something year history of use on websites?

Javascript is the only language that browsers support. Would you prefer if browsers historically supported only Python instead of Javascript?

Expressing only emotions toward a tool is inefficient and hinders improvement of the tool. Please help the conversation by identifying specific issues or failings.

<comment><USER6> It's just a poorly designed language that teaches the wrong things. Once the things it teaches are learned they are difficult to unlearn. You forget how to do things without JavaScript when you write JavaScript for a while. You forget how to do much of anything that is not JavaScript.

<comment><USER7> > * Once the things it teaches are learned they are difficult to unlearn.*

Could you describe one of these "things it teaches"? Is it a concrete concept like ternary operators? Having gone through Excel, VB briefly, and Powershell, Javascript was my first exposure to ternary.

</comment></comment></comment></comment></comment><comment><USER8> > UMF is being used in IoT (Internet of Things) applications where message > sizes need to remain small. To allow UMF to be used in resource contained > environments a short form of UMF is offered.

Then offer it in Protobuf :-) In general, I don't understand where this would be used instead of an app's specific envelope. The use cases should be specified better because it's really easy for any app to just send their own preferred JSON format without following this.

Tangentially related, I similarly tried to make a messaging format (but with more bells and whistles and more about the transfer, storage, permissions, etc). The proto files are at [0] and the messaging platform is still under active development.

0 - [https://github.com/cretz/yukup/tree/0cc926f98d01fba64b818383...](https://github.com/cretz/yukup/tree/0cc926f98d01fba64b818383ee9763cbe61a6c64/yukup/pb/proto)

</comment><comment><USER9> A few issues I have with UMF.

It's missing a mission statement, or use case.

The intro says it's used to avoid inconsistent formatting, but there exists other message formats.

The body field is application specific, which introduces an area for inconsistent formatting and reduces the interoperability, or universalness, of the message format.

The destination doesn't need to be in the message, most of the time the destination is implicit in where the message is sent. (If I send a UMF over email the destination would be in the email metadata and the UMF metadata)

The total amount of metadata that would be included in a UMF message sent over TCP/IP would be silly.

There are arbitrary and undefended specification decisions. The transport protocol is left ambiguous, but both the schema and the format are specified. The metadata around body is very standardized, but anything goes inside body, which is the primary payload.

<comment><AUTHOR> +1 for mission statement, use case.

The point about inconsistent formatting is that by aligning a team(s) on how a message is formatted groups can avoid the introduction of multiple message formats between distributed services.

It's true the body field does introduce inconsistency and that's left for the application developers to resolve. The envelope fields are intended to be used in queuing and routing situations.

I disagree with "The destination doesn't need to be in the message". What about the use case where a message is forwarded or moves through proxy services?

+1 for metadata being larger than the payload :-D - Can't debate that. The only required fields are 'to', 'from' and 'body' and the short form of UMF can be used. Still, we've encountered situations where that metadata is still larger than the payload. But that doesn't completely invalidate the presence of the envelope in a distributed application.

Thanks, I really appreciate the time you took to offer feedback!

</comment></comment><comment><USER10> Don't fields need to be sorted in order for signatures to be reproducible with JSON objects? there's no mention of that.

<comment><USER11> Lots of canonicalization required, and it's quite easy to run into validation bugs across implementations (does your $LANGOFCHOICE serialize JSON exactly the same as the sender's?)

</comment></comment><comment><USER12> My dude should quit his architect positions.

Consistent hashing of messages requires that every application which handles the message will lay the fields out in the same manner, this is a recursive problem for every layer that will put its data in the UMF. This right out the gate creates caching complexity issues.

Also for being so no cache control options by default.

Also there isn't an error handling/logging field so the responder will have to do something out-of-band to acknowledge errors.

Also there's no mention of compression or alternative message formats, XML, proto, etc.

The sender field should likely be a URI encoded data. Then which mode (of several) which could get the message is an infrastructure not an encoding program. Getting this deep here is kind of bad, same with the TTL. If we are going this deep... why no cache control/consistent hashing/compressing?

If you care about strictness or correctness you should use RFC3339 instead of ISO8601. Also not including an implicit UnixTime/UnixTime Nano seconds is a poor choice.

Offering alternative keys for standard keys is dumb. This feels like an accident that nobody caught until later, and made a backwards compatible monkey patch.

Why haven't you considered protobuf if you have concerns about message size, and are working in power constraints? UTF/Base64 is kind of shitte for power savings.

<comment><AUTHOR> Hahaha. My dude, it's a damn good thing I'm not applying for your startup! And a great thing that my current and past employers didn't think I should resign. So you know what? I'm going to keep up this charade for a bit longer. Besides, the pay is great! :-D

The conical issue with regards fields and signatures is definitely and without question a valid point and should probably be removed from the spec.

You raise good points. I'll definitely reconsider your feedback in future iterations!

Your point about a logging field is interesting, but the MID field could be used in an out of band error acknowledgment.

Protobuf is great - but what if you don't need or want it?

Thanks for taking the time to comment!

</comment></comment><comment><USER13> Projects like these need a motivation section.

It's not clear what the usecase is.

</comment><comment><USER14> I love open source projects with no documentation or Getting Started guides.....said no one ever.

<comment><USER15> They put everything in umf.md rather than README.md [https://github.com/cjus/umf/blob/master/umf.md](https://github.com/cjus/umf/blob/master/umf.md)

<comment><AUTHOR> In an earlier version of the docs I actually had the spec in the readme but felt the sheer size was enough to send folks running. Using the readme to describe the spec (which I realize needs work!) allowed for a clean separation.

<comment><USER15> You should probably link to the spec or something in the README so it's easier for people to find.

</comment></comment></comment></comment><comment><AUTHOR> Wow - I really ruffled some feathers with this post :-D As I scanned the feedback, I found myself agreeing with some, but not all, of the comments.

I actually found some of the direct attacks amusing and got a good laugh. That said, I'd like to thank everyone who took the time to comment. One of the goals of any specification should be to iterate the spec based on the valuable feedback of others. I'll definitely take this opportunity to do that.

Thanks again.

</comment><comment><USER16> Doesn't JSON-LD (especially AcitivityPub+co) mostly deal with this already?

</comment><comment><USER17> [https://github.com/edn-format/edn](https://github.com/edn-format/edn)

edn is an extensible data notation. A superset of edn is used by Clojure to represent programs, and it is used by Datomic and other applications as a data transfer format. This spec describes edn in isolation from those and other specific use cases, to help facilitate implementation of readers and writers in other languages, and for other uses.

</comment><comment><AUTHOR> Reading through the comments here I'm realizing that my single biggest error may have been the use of the word "Universal" :-D When you consider the spec as a "basis for agreement" between distributed application authors and not a unified theory of messaging - then the spec becomes a lot clearer.

</comment><comment><USER18> I'll just note, once again, how verbose, unattractive & difficult to parse JSON is compared to S-expressions. Here are several of the examples in the spec in both formats, in order (I've rearranged the field so that required fields come first & optional fields come later).

2.1:

        {
          "mid": "ef5a7369-f0b9-4143-a49d-2b9c7ee51117",
          "rmid": "66c61afc-037b-4229-ace4-5ec4d788903e",
          "to": "uid:123",
          "from": "uid:56",
          "type": "dm",
          "version": "UMF/1.4.3",
          "priority": "10",
          "timestamp": "2013-09-29T10:40Z",
          "body": {
            "message": "How is it going?"
          }
        }

        (message
         ef5a7369-f0b9-4143-a49d-2b9c7ee51117
         (to uid:123)
         (from uid:56)
         (version SMF/1.4.3)
         (timestamp 2013-09-29T10:40Z)
         (rmid 66c61afc-037b-4229-ace4-5ec4d788903e)
         (type dm)
         (priority 10)
         (body
          (message "How is it going?")))

2.2.11:

        {
          "mid": "ef5a7369-f0b9-4143-a49d-2b9c7ee51117",
          "to": "uid:56",
          "from": "game:store",
          "version": "UMF/1.3",
          "timestamp": "2013-09-29T10:40Z",
          "body": {
            "type": "store:purchase",
            "itemID": "5x:winnings:multiplier",
            "expiration": "2014-02-10T10:40Z"
          }
        }

        (message
         ef5a7369-f0b9-4143-a49d-2b9c7ee51117
         (to uid:56)
         (from game:store)
         (version UMF/1.3)
         (timestamp 2013-09-29T10:40Z)
         (body (type store:purchase)
               (itemID "5x:winnings:multiplier")
               (expiration 2014-02-10T10:40Z)))

188.8.131.52

Note how JSON has to rely on metadata to indicate that a Base64 sequence, whereas it's natively supported by canonical S-expressions. Note also how the S-expression format natively supports types ('display hints') for its values.

        {
          "mid": "ef5a7369-f0b9-4143-a49d-2b9c7ee51117",
          "to": "uid:134",
          "from": "uid:56",
          "version": "UMF/1.3",
          "timestamp": "2013-09-29T10:40Z",
          "body": {
            "type": "private:message",
            "contentType": "text/plain",
            "base64": "SSBzZWUgeW91IHRvb2sgdGhlIHRyb3VibGUgdG8gZGVjb2RlIHRoaXMgbWVzc2FnZS4="
          }
        }

        (message
         ef5a7369-f0b9-4143-a49d-2b9c7ee51117
         (to uid:134)
         (from uid:56)
         (version SMF/1.3)
         (timestamp 2013-09-29T10:40Z)
         (body
          (type private:message)
          [text/plain]|SSBzZWUgeW91IHRvb2sgdGhlIHRyb3VibGUgdG8gZGVjb2RlIHRoaXMgbWVzc2FnZS4=|))

220.127.116.11

One might expect that S-expressions might shine when it comes to sending multiple items, and of course one would be correct.

Also note how the parallel structure of the message & message/body/message objects raises the question of whether the message/body/message schema should also be UMF.

        {
          "mid": "ef5a7369-f0b9-4143-a49d-2b9c7ee51117",
          "to": "uid:134",
          "from": "chat:room:14",
          "version": "UMF/1.3",
          "timestamp": "2013-09-29T10:40Z",
          "body": {
            "type": "chat:messages",
            "messages": [
              {
                "from": "moderator",
                "text": "Susan welcome to chat Nation NYC",
                "ts": "2013-09-29T10:34Z"
              },
              {
                "from": "uid:16",
                "text": "Rex, you are one lucky SOB!",
                "ts": "2013-09-29T10:30Z"
              },
              {
                "from": "uid:133",
                "text": "Rex you're going down this next round",
                "ts": "2013-09-29T10:31Z"
              }
            ]
          }
        }

        (message
         ef5a7369-f0b9-4143-a49d-2b9c7ee51117
         (to uid:134)
         (from chat:room:14)
         (version SMF/1.3)
         (timestamp 2013-09-29T10:40Z)
         (body
          (type chat:messages)
          (messages
           (message
            (from moderator)
            (text "Susan welcome to chat Nation NYC")
            (ts 2013-09-29T10:34Z))
           (message
            (from uid:16)
            (text "Rex, you are one lucky SOB!")
            (ts 2013-09-29T10:30Z))
           (message
            (from uid:133)
            (text "Rex you're going down this next round")
            (ts 2013-09-29T10:31Z)))))

2.2.17

Note that there is a complex canonicalisation procedure for the JSON object, and that the sender must mutate the signed object; by contrast, the S-expression format is properly layered and doesn't mutate signed objects (which implies that it's possible to chain signatures cleanly).

        {
          "mid": "ef5a7369-f0b9-4143-a49d-2b9c7ee51117",
          "to": "uid:123",
          "from": "uid:56",
          "version": "UMF/1.4.6",
          "signature": "c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e",
          "body": {}
        }

        (signature
         (message
          ef5a7369-f0b9-4143-a49d-2b9c7ee51117
          (to uid:123)
          (from uid:56)
          (version SMF/1.4.6)
          (body))
         |c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e|)

It's not to late to switch away from JSON, it really isn't.

<comment><USER19> Looking at the examples and thinking about how a C like program would process them, the S-Expressions look way more complex.

With JSON you know immediately what kind of datatype you are dealing with. You see a { you allocate an associative array, or if you see a [ you know you're about to get an ordered list. With S-Expressions it seems like you need to parse the entire thing and then figure out what kind of data structure you have.

In fact there doesn't appear to be any indicator at. Looking at 220.127.116.11 we see in the JSON that "messages" is an ordered list, but the content of the message is an associative array, but in the S-Expression they look identical.

So in C-like land you would end up with a big nested mess of arrays that are slow to parse and even harder to figure out the address of any object. There's a ton of friction that you don't have with JSON data.

<comment><USER20> When I need to parse or validate S-expressions, I just write the functions (here message, to, from, timestamp, etc.) so that eval()ing the S-expressions either validates it or returns whatever data structure I need.

So the easiest way would be to use or code a small lisp interpreter in C and eval the S-expression. For example, one could use Chicken Scheme to do so.

<comment><USER21> Or we could...not...evaluate random code potentially coming from hostile environments. That would also be cool and good.

And, yes, it's possible to have vulnerabilities in a JSON parser--but it is orders of magnitude easier to have them in an _arbitrary language parser_.

<comment><USER20> If you evaluate it in an environment where only the functions you choose are defined, the security risk is nil.

Validating a document is a complex, domain-dependant problem. It is far easier to create a secure Domain-Specific Language to handle this than to end up with an accidentally Turing complete abomination like XSLT: [http://www.unidex.com/turing/utm.htm](http://www.unidex.com/turing/utm.htm)

<comment><USER22> >If you evaluate it in an environment where only the functions you choose are defined, the security risk is nil.

Oh. So all you have to do is write perfectly secure code and run it in a perfectly secure environment, and nothing bad can possibly happen.

Well shit, why didn't anyone else ever think of that?

</comment></comment></comment></comment></comment></comment><comment><USER23> WS-* meets JSON.

</comment><comment><USER24> This spec should be rebuilt from the start to extend [http://cloudevents.io](http://cloudevents.io) .

</comment><comment><USER25> [https://xkcd.com/927/](https://xkcd.com/927/)

</comment><comment><USER26> Direct link to the spec: [https://github.com/cjus/umf/blob/master/umf.md](https://github.com/cjus/umf/blob/master/umf.md)

Relevant xkcd: [https://xkcd.com/927/](https://xkcd.com/927/)

<comment><USER27> Relevant comment by Linus Torvalds on standards: "I've said this before, and I'll say it again: a standards paper is just so much toilet paper when it conflicts with reality. It has absolutely _zero_ relevance. In fact, I'll take real toilet paper over standards any day, because at least that way I won't have splinters and ink up my arse." [http://www.yodaiken.com/2018/06/07/torvalds-on- aliasing/](http://www.yodaiken.com/2018/06/07/torvalds-on-aliasing/)

<comment><AUTHOR> Ah Linus - enough said. The UMF spec wasn't intended to be a standards paper. You might be able to tell it isn't formatted as such. Based on the comments in this post - it has at the very least helped spark interesting feedback and debate.</comment></comment></comment>


Ask: Review my MVP Doxela.com - <AUTHOR>

Hello HN.
I would like your feedback on Doxela.
Doxela is way to quickly share powerpoint and pdf with several viewers. It is an imgur for pdfs and ppts. <comment><USER2> Very nice. I'm not sure what your revenue model is going to be nor how it compares other document sharing platforms like Slideshare or Scribd or whatever is comparable (I don't find myself using that sort of service often), but I really like the simplicity. I found it intuitive and easy to use.

One thing I noticed, it didn't seem to accept the new Microsoft Office formats (pptx vs. ppt), which may create a problem for you eventually.

Also, in addition to PDF I think it would be useful for you to offer Word (doc/docx) sharing. I imagine many potential users would be more likely to have a Word doc than a PDF to share, and may find it difficult to convert to Word document to a PDF file.

Personally, I may be more likely to use a service like this if (a) I could establish a password to protect viewing the file, in addition to the obscure URL and (b) I could offer the people I share it with the option of downloading the source file directly, rather than just viewing it online.

PS: I don't think I'll find that name (doxela) memorable.

<comment><AUTHOR> Thank you Spokey.

I am using Google Doc Viewer and they currently do not support pptx.

Good idea on the password, and support for .doc and .docx.

I tried to register doxdox, and dox.ly but they were already taken so I settled for Doxela.

Thank you very much for the feedback. Maybe I will repost another Ask HN by the end of the week, since only a few people actually voted/visited, so maybe they missed it.

</comment></comment><comment><AUTHOR> Clickable <http://www.doxela.com>

<comment><USER3> Hi Rokhayakebe,

some suggestions and observations

1\. The label manage is not clear enough. I guess anyone who has the manage link has admin right and can delete the doc.

2\. Please check the screenshot. For some reasons the powerpoint I uploaded took up the whole screen. <http://tinypic.com/r/3524zed/6>

3\. I liked the simplistic approach. I guess it will be better if you can make the upload field bigger and bring it to the centre of the page, maybe somewhat similar to google and the value prop can be placed above it.

All the best

<comment><AUTHOR> Thank you for the feedback Mailarchis,

1\. Maybe I should change Manage to Admin. I think that is a more universal term for top level access.

2\. That is the way it is supposed to look. Should it be different? larger?

3\. I may A/B test positions.

Thanks again for the feedback.

<comment><USER3> Hi,

Ideally I would like the whole slide to be displayed in the browser without having to scroll down. So if possible you can test by making it bit smaller.

Cheers</comment></comment></comment></comment>


Generators come to PHP - <AUTHOR> http://www.lornajane.net/posts/2013/simplest-php-generator-example?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+lornajane%2Fphp+%28LornaJane+PHP%29

<comment><USER2> I expect some hate towards PHP here, so I want to say something.

I've been working on some big PHP applications lately and I can say that the language is very much moving away from its past bad reputation.

PHP 5.4 is a quite modern language, with a pretty decent object-oriented structure, namespacing, lambdas, closures and most of the usual goodies.

It is true that you _can_ still write terrible PHP even with the last version, but you don't _have_ to. PHP has now most of the tools necessary so you can use it on pair with languages like Python or Ruby, and the new generators on 5.5 brings it even further.

<comment><USER3> > It is true that you can still write terrible PHP even with the last version, > but you don't have to.

One can write terrible code in any language though :). A language is only as good as the person using it, just as a canvas & brush is only as good as the artist. While some might complain it doesn't look as typographically pleasing as some other languages, as long it does not resemble COBOL or Visual Basic, I do not consider it hideous by any means.

I have no quarrel though with PHP since 5.3 really other than they need to write an Object Oriented front end for PostgreSQL for their API like they have for MySQLi. Using PostgreSQL in PHP with something like PDO doesn't work when you want to do asynchronous queries (which MySQLi and PostgreSQL support). I ended up writing a wrapper class sometime ago around the PostgreSQL PHP API just to deal with that issue, but official API support would be better.

I don't use PHP quite as much as Python for web stuff as I once did, but it would be my alternative goto (no pun intended[1]) language for web stuff.

[1] <http://php.net/manual/en/control-structures.goto.php></comment></comment>


CMS interface design and evolution - <AUTHOR> http://gregsherwood.blogspot.com/2008/10/interface-design-interative-process.html

<comment><AUTHOR> I work with the guys who developed this new CMS, which truly has to be seen to be believed. It contains some great features coupled with a very lickable interface.

Here is a video recorded at our last user conference 2 weeks ago which goes through many features that I believe raises the bar for CMS design and development: <http://www.vimeo.com/2040803></comment>