quote:

The Business Analysis Benchmark report presents the findings from surveys of over 100 companies and definitive statistics on the importance and impact of business requirements on enterprise success with technology projects. The survey focused on larger companies and looked at development projects in excess of $250,000 where significant new functionality was delivered to the organization. The average project size was $3 million.

[...]

The report finds 2 basic scenarios for companies:

1. Scenario 1 (68% of companies): project success is ‘Improbable’: Projects might succeed – but not by
   design. Based on the competencies present, these companies are statistically unlikely to have a successful
   project. 68% of companies fit this scenario.
   
2. Scenario 2 (32% of companies): project success is ‘Probable’: Companies that can expect to have successful projects, by design, due to the investments that they have made in Business requirements process. 32% of companies fit this scenario
   

[...]

The following are a few key findings in the study:

1. Companies with poor business analysis capability will have three times as many project failures as successes.
   
2. 68% of companies are more likely to have a marginal project or outright failure than a success due to the way they approach business analysis. In fact, 50% of this group’s projects were “runaways” which had any 2 of:
   
   • Taking over 180% of target time to deliver
     
   • Consuming in excess of 160% of estimated budget
     
   • Delivering under 70% of the target required functionality
     
3. Companies pay a premium of as much as 60% on time and budget when they use poor requirements practices on their projects.
   
4. Over 40% of the IT development budget for software, staff and external professional services will be consumed by poor requirements at the average company using average analysts versus the optimal organization.
   
5. The vast majority of projects surveyed did not utilize sufficient business analysis skill to consistently bring projects in on time and budget. The level of competency required is higher than that employed within projects for 70% of the companies surveyed.
   

quote:

It is also true that people who see business requirements as simply a ‘deliverable’ or written document of some kind will continue to fail. The findings clearly indicate that only companies which are committed to achieving excellence in business requirements through improvement involving people, process, and documentation/information quality standards will be consistently, predictably successful.

[...]

The data from this study demonstrates clearly that a project manager who believes the quality of requirements received is below average would be better served to REDO requirements than to proceed on a large project despite the uproar this decision would create with business stakeholders

[...]

In absolute terms, the quality of requirements will dictate the time and cost of the solution.

[...]

The focus of companies must shift to the quality of Requirements Discovery as a process and away from “Business Requirements” as a thing that either happened or didn’t at the beginning of a project if they hope to consistently deliver successful projects.

[...]



[...]

The risk key areas (in order of importance) from the research are:

1. Uncovering interdependencies
   
2. Setting unambiguous goals
   
3. Documenting information required to support the process
   

Improving the people, tools, and processes used in these areas will not guarantee success, but it does mitigate against failure

[...]



[...]

Effective scoping when combined with strong business requirements discovery skills yielded a successful project in 80% of circumstances

MononcQc posted:

Related: The Impact of Business Requirements on the Success of Technology Projects by IAG.

suffix posted:

yeah you really should have 100% test coverage on large p-lang projects. that's it, that's the whole trick.

luckily even the worst p-lang mock utils i've used are tons better than anything i've found for java. it's not like writing tests in p-langs is hard.


jetbrains pycharm is actually pretty good

Spime Wrangler posted:

is intellij + plugins an effective replacement for their language specific ides?

MononcQc posted:

It's just hilariously bad that 70% of projects appear doomed from the start because people can't figure out requirements.

JewKiller 3000 posted:

https://github.com/mozilla/rust/issues/13871

Zombywuf posted:

Very few people are ever taught how to gather requirements, and almost no-one knows what it is they know that lets them do their job.

Fun example, $SOME_COMPANY^* has decided they need a better way to share documents between departments, because one department keeps stripping metadata off the documents other departments put on it. The answer they've come up with is a new folder structure, which is to say one big folder where the files are names <dept 1 id>-<dept 2 id>-<dept 3 id>-...-<dept n id>.doc. No-one has bothered to ask why every department has a different set of ids and no-one has asked what it is people actually do with the documents so they came up with this.

They reckon it'll take 6 months to 2 years to implement.





* true story

JewKiller 3000 posted:

https://github.com/mozilla/rust/issues/13871

MeramJert posted:

my company had 3 different overlapping document control systems and eventually everyone stopped using all of them and now everyone just emails files around and each department has come up with their own crappy ad hoc system. my old department used a big folder on a shared drive with 3 excel files you had to update by hand whenever you input a new document into the "system" so people would know what files were there and which subdirectory to look in. my new department uses google drive

MeramJert posted:

whats pine? or is this a bad joke

MeramJert posted:

my company had 3 different overlapping document control systems and eventually everyone stopped using all of them and now everyone just emails files around and each department has come up with their own crappy ad hoc system. my old department used a big folder on a shared drive with 3 excel files you had to update by hand whenever you input a new document into the "system" so people would know what files were there and which subdirectory to look in. my new department uses google drive

AlsoD posted:

https://www.fpcomplete.com/user/icelandj/Pattern%20synonyms

Being forced to pattern match on implementation details was always a bit annoying and is one of the use cases for prisms. Now you don't have to!

AlsoD posted:

https://www.fpcomplete.com/user/icelandj/Pattern%20synonyms

Being forced to pattern match on implementation details was always a bit annoying and is one of the use cases for prisms. Now you don't have to!

Squinty Applebottom posted:

lol @ the department wide emails that ask if anyone has the excel doc open please close it im trying to update it

prefect posted:

sorry i didn't get back to this thread sooner -- many moons ago, elm was an e-mail client. and pine came afterwards -- it stood for "pine is not elm"

AlsoD posted:

https://www.fpcomplete.com/user/icelandj/Pattern%20synonyms

Being forced to pattern match on implementation details was always a bit annoying and is one of the use cases for prisms. Now you don't have to!

MononcQc posted:

MononcQc posted:

The feature I'd really love languages to have is higher-order pattern matching, where you can submit patterns and values extracted to get what you want. It would allow to do poo poo like iterate over pattern while applying transformations from a user-sent pattern rather than having to use some lambda.

The closest thing I've seen is doing it through macros in Racket, but it requires lots of work:

MononcQc posted:

The feature I'd really love languages to have is higher-order pattern matching, where you can submit patterns and values extracted to get what you want. It would allow to do poo poo like iterate over pattern while applying transformations from a user-sent pattern rather than having to use some lambda.

The closest thing I've seen is doing it through macros in Racket, but it requires lots of work:

code:

> (define employees '((janitor bob 12000) (boss lowtax 30000) (boss peter 200000)
                      (temp jim 0) (coder janet 60000)))

;; find the boss' bonuses at 5%

> (filter-extract employees [(list 'boss _ salary) salary])
'(30000 200000)
> (filter-extract employees [(list 'boss _ salary) (* salary 0.05)])
'(1500.0 10000.0)

;; other manipulations

> (filter-extract employees [(list role name _) (list name role)])
'((bob janitor) (lowtax boss) (peter boss) (jim temp) (janet coder))
> > (filter-extract employees ['bad-pattern 'bad-return])
'()

The code to support this is

code:

#lang racket
(require racket/match)

(define-syntax-rule (matcher val pattern)
 (match val
  pattern
  [_ `nil]))

(define-syntax-rule (filter-extract start-lst pattern)
  (begin (define (f-ext lst)
    (match lst
      ['() '()]
      [(cons hd tl) (let [(v (matcher hd pattern))]
                      (if (eq? 'nil v)
                          (f-ext tl)
                          (cons v (f-ext tl))))]))
  (f-ext start-lst)))

And it sucks to have to define it for all kinds of structures. I'd really like to see a language allow it more naturally. In the end passing a function is simple enough, I guess, but the idea to allow patterns as data with custom bindings and whatnot is pretty cool and generally more terse than using higher order anonymous functions.

JewKiller 3000 posted:

https://github.com/mozilla/rust/issues/13871

quote:

Personally I'd add a no_horrors cfg option or something to disable it in the rare cases where 2k is considered important, unless the potential for user confusion is considered to great to keep the behaviour at all.

Cold on a Cob posted:

lmao

Cold on a Cob posted:

lmao

Malcolm XML posted:

I wont claim Haskell is prevalent in industry but multiple groups in major banks use it. F# is heavily used in trading/hedge funds and C# is near ubiquitous.

Notorious b.s.d. posted:

i tried really hard not to commit forums necromancy but reading the backlog made me mad


hedge funds and small fry traders are the financial equivalent of startups. they use whatever technologies the first technical hire has a hardon for. personally, i've heard of c, c++, java, perl, and ruby*. but i'm sure you can find anything








* yes. ruby. the scripting language. i used to know a guy who literally wrote trading platforms in ruby. that was his job. he made a lot more money than i do

MeruFM posted:

This sounds about right.
I cannot imaging GC being so bad that it needs to stop the entire machine for several seconds.
Are they passing around a global array/hash so big that the OS starts loading it to virtual memory?

MononcQc posted:

The feature I'd really love languages to have is higher-order pattern matching, where you can submit patterns and values extracted to get what you want. It would allow to do poo poo like iterate over pattern while applying transformations from a user-sent pattern rather than having to use some lambda.

The closest thing I've seen is doing it through macros in Racket, but it requires lots of work:

code:

> (define employees '((janitor bob 12000) (boss lowtax 30000) (boss peter 200000)
                      (temp jim 0) (coder janet 60000)))

;; find the boss' bonuses at 5%

> (filter-extract employees [(list 'boss _ salary) salary])
'(30000 200000)
> (filter-extract employees [(list 'boss _ salary) (* salary 0.05)])
'(1500.0 10000.0)

;; other manipulations

> (filter-extract employees [(list role name _) (list name role)])
'((bob janitor) (lowtax boss) (peter boss) (jim temp) (janet coder))
> > (filter-extract employees ['bad-pattern 'bad-return])
'()

The code to support this is

code:

#lang racket
(require racket/match)

(define-syntax-rule (matcher val pattern)
 (match val
  pattern
  [_ `nil]))

(define-syntax-rule (filter-extract start-lst pattern)
  (begin (define (f-ext lst)
    (match lst
      ['() '()]
      [(cons hd tl) (let [(v (matcher hd pattern))]
                      (if (eq? 'nil v)
                          (f-ext tl)
                          (cons v (f-ext tl))))]))
  (f-ext start-lst)))

And it sucks to have to define it for all kinds of structures. I'd really like to see a language allow it more naturally. In the end passing a function is simple enough, I guess, but the idea to allow patterns as data with custom bindings and whatnot is pretty cool and generally more terse than using higher order anonymous functions.

MononcQc posted:

And it sucks to have to define it for all kinds of structures. I'd really like to see a language allow it more naturally. In the end passing a function is simple enough, I guess, but the idea to allow patterns as data with custom bindings and whatnot is pretty cool and generally more terse than using higher order anonymous functions.