HN user

integraton

902 karma

From NY, then Minneapolis, SF, and Denver, plus a few others.

topcolor: FF0000

Posts0
Comments221
View on HN
No posts found.

Only by manually editing internal program files using the command line. Also,

You will need to apply these changes after every update to disable collection of usage data. These changes do not survive product updates.

Since I haven't noticed anyone mention it directly while advocating for voting functionality: GitHub issues originally had voting. The feature was removed with the release of Issues 2.0. Back when the GitHub blog had comments, the Issues 2.0 announcement's comments included this one from pjhyett (https://web.archive.org/web/20110412131836/https://github.co...)

Issue ordering and voting were used by an incredibly small number of users and we made the decision to drop them. Leaving features in that only ten people use is how to create Jira, not GitHub.

Obviously, that was a while ago and things might be different now.

Physical ability and job qualifications are a central issue in the debate about discrimination in hiring. It's not just limited to disabilities, since the same debate has repeatedly taken place around the issue of whether women are physically qualified for certain jobs, as can be seen in the current debate over whether women are physically qualified for special operations roles in the US military.

Absolutely. There are jobs that discriminate against people with eyesight disabilities (some aircraft pilot jobs, for example) and there are many products that don't account for people wearing glasses.

People with glasses are widely stereotyped as nerds or geeks and often experience bullying.

People wearing glasses were also reportedly targeted in mass killings by the Khmer Rouge due to that same stereotype.

Rbenv 1.0.0 11 years ago

They are tools for managing multiple installed versions of a programming language. When developing software, we often specify dependencies using version numbers, which indicate the version of the language or library that should be used when running the software. Running the software with the specified language runtime or library version ensures that the expected features of that library or language runtime are available and also helps avoid unexpected issues related to differences in the environments, including different developer's local systems as well as remote server environments.

In the case of a programming language runtime, if you have one project that's configured to use version 2.2.4 of a language and another that's configured to use version 2.1.0, these tools provide an easy way to install and switch between the two versions.

This is not unique to Ruby, and similar projects exist for other languages. For example, nvm (https://github.com/creationix/nvm) and n (https://github.com/tj/n) provide something similar for Node (JavaScript), gvm (https://github.com/moovweb/gvm) for Go, and multirust (https://github.com/brson/multirust) for Rust.

It is when it ignores class and takes people of different ethnic and economic groups and treats them as homogeneous based on skin color alone.

Your comment is interesting since it contains a lot of political extremism and insults toward people who hold different viewpoints, while also advocating censorship.

useerup, virtually everything in your comment is irrelevant handwaving and obfuscation, including a bunch of irrelevant comments about features that are internal to the PowerShell runtime.

No matter how much you want to try to talk around it, PowerShell is a .NET CLI, the object pipeline exists within its .NET runtime, and the commands are instances of .NET classes. Unix shells work primarily with arbitrary executables outside of the shell runtime using OS system calls to create pipelines with standard streams.

Here's the cold hard fact stated yet again: PowerShell's object pipeline is functionally analogous to function chaining in languages like Ruby, Python, and JavaScript, not Unix pipelines.

It's fundamentally different.

That's because the object pipeline is functionally analogous to function chaining within a single runtime like in Python or Ruby, not streaming data between arbitrary executables like in Unix pipelines.

This would be a lot clearer if PowerShell advocates compared it to things that it's actually functionally analogous to, but they are trying to position it as a Unix shell competitor.

The word "shell" in this context already means something. A text shell is a command line interpreter (https://en.wikipedia.org/wiki/Shell_(computing)#Text_.28CLI....). There are many shells that do not use the pipeline convention (e.g., irb), so your attempt to redefine it to promote PowerShell fails from the start.

PowerShell's object pipeline is functionally analogous to function chaining in languages like Ruby, Python, and JavaScript, not Unix pipelines. PowerShell's object pipeline does not exist outside of the .NET runtime and you can not stream objects between arbitrary executables outside of the .NET runtime.

You can't compare an apple to an orange and say one is "objectively better," no matter how hard PowerShell advertisers try to pretend their apple is an orange.

PowerShell's object pipeline only exists within the PowerShell/.NET runtime and is functionally analogous to method/function chaining in languages like JavaScript and Ruby. The object pipeline does not exist outside of the PowerShell/.NET runtime.

Pipelines in Unix shells use OS-level functionality to connect standard streams of data, often encoded as text, between arbitrary executables written in any language.

The reason this is confusing is because one of the main tactics used in PowerShell promotion is to disingenuously compare PowerShell's "object pipeline" to Unix pipelines in order to try to make it appear to be more novel than it is, when they should be comparing it to what it's functionally equivalent to, which is function chaining within a single runtime.

Stronger Shell 11 years ago

PowerShell is more like a worse Python and its core functionality is not the same as that of Unix shells.

PowerShell's commands ("cmdlets") are .NET classes within PowerShell, not arbitrary executables as in Unix shells. PowerShell's "object pipeline" is function chaining like in Ruby, not using OS-level pipelines as in Unix shells.

PowerShell is really just a .NET CLI, analogous to the Ruby's irb or Python's CLI, but dressed up to look like a Unix shell.

Those are different articles. Your comment is analogous to linking to old Docker article discussions when a new article is posted in order to try to discourage discussion of Docker in general.

the truck is still going to drive much of his delivery route to deliver the heavy packages

How this will exist in the future in practice is pure speculation at this time. There are many different factors (autonomous vehicles, smarter routing techniques, routing changes as the burden is shifted to non-truck delivery systems, and increased demand for small package delivery as more shopping is done online, for example) that could dramatically reshape the delivery landscape.

Furthermore, heavy packages delivered to consumers in the US, like those containing appliances and furniture, are already routinely delivered by in-house or smaller delivery services rather than UPS, FedEx, or US Mail.

MIT, where Ochsendorf is a professor, has the Aga Khan Program for Islamic Architecture [1] (Harvard has a sister program [2]).

Stari Most is also a well-known tourist destination. Its destruction occurred during a war the US was involved in and its destruction, rebuilding, and symbolism in the war were widely reported in US media. [3] Today, it's popular on mainstream sites like reddit. [4]

1. http://web.mit.edu/akpia/www/generalinformation.htm

2. http://agakhan.fas.harvard.edu/icb/icb.do

3. https://www.google.com/search?q=site:nytimes.com+%22mostar%2...

4. https://www.google.com/search?q=site:reddit.com+%22mostar%22...

cmdlets are NOT just .Net classes

Yes they are.

The fact that you (and others I've seen here and elsewhere) continue to believe otherwise further demonstrates how deceptive PowerShell's design is.

What's interesting is that the cmdlet documentation is very clear:

"Cmdlets differ from commands in other command-shell environments in the following ways:

"Cmdlets are instances of .NET Framework classes; they are not stand-alone executables....

"Cmdlets do not generally do their own parsing, error presentation, or output formatting. Parsing, error presentation, and output formatting are handled by the Windows PowerShell runtime."

https://msdn.microsoft.com/en-us/library/ms714395%28v=vs.85%...

...Powershell. They have command names...

Except that PowerShell commands, 'cmdlets', are really just .NET classes that run within PowerShell, like Ruby and Python classes, none of which are the same as working with GNU or BSD utilities and other executables in POSIX shells. That PowerShell's interface obfuscates its true nature is a huge violation of honest design, a massive violation of what's described in "Design of Everyday Things," leads to false comparisons, and misleads people into thinking it is providing the same functionality as working with executables in POSIX shells when it's actually providing chaining functionality like that in other scripting languages.

Lambda is a focused, specialized service for running short-lived processes triggered by events and is one of the many services provided by AWS that have formed the foundation for many companies and other PaaS providers for many years, while Azure Mobile App Service is a packaged and branded collection of services including data storage and push notifications that is similar to backend service providers like Parse and Urban Airship pre-pivot (at least one of which was built on top of AWS), and tries to offer services comparable to a subset of other AWS services including SNS (push notifications), RDS or DynamoDB (databases as a service), among others.

It's also quite strange to spotlight Azure as if it's doing something at all remarkable considering the "Mobile Backend as a Service" market has existed for years and actually seems to be on the decline, at least as a standalone segment.

If they were being honest, the actual reason is that circular avatars have been trendy and the norm for new designs on the web, iOS, and Android for the past 3 to 4 years, and the two primary reasons they became popular were because border-radius became supported widely enough around that time, and because photographs of faces arguably look better in a circular frame, at least according to current tastes.

Here's a quora thread from back in 2013 discussing it:

http://www.quora.com/Why-are-many-UI-designers-using-round-p...

Chrome doesn't use WebKit, it uses Blink, a fork of WebKit. I'm only referring to WebKit, the Apple open source browser project that builds and works on every major operating system including Windows. If you also want to talk about Blink, Google's browser project that, unlike IE/Spartan/Edge, also works on every major operating system, then that's fine, too.

While we are at it, let's talk about Mozilla's browser and rendering engine that also works on every major operating system.