The Curious Engineer

All blogs / Software / engineering practice

The Shape of Code

shape-of-code.com

Software / engineering practiceAI / MLScience

’10’15’20’25
Posts
938 from 2 Dec 2008 to 25 Oct 2026
Posting
weekly (52 in the last year)
Kind
personal blog
Feed
https://shape-of-code.com/feed/

2026 43

  1. Mutating Lean proofs looking for issues
  2. Program to extract x/y coordinates of points in pdf graphs
  3. Programming language choice is becoming a build option
  4. Impact of input distribution on faults experienced
  5. LLM handling of programming language differences
  6. Source line length before coding agents
  7. Project implementation time savings using coding agents
  8. Software effort estimation in 2026
  9. Number of projects worked on concurrently
  10. End-user Pentium and SIMM prices in the 1990s
  11. Computers installed in the UK during the 1960s
  12. 2026 in the programming language standards’ world
  13. Flagging poor algorithm choice: LLMs next role
  14. Distribution of number of statements in functions
  15. Call graph neighbourhood and fault prediction
  16. Classification of code updates
  17. Detailed management data on 1,211 software projects
  18. A model of fault experiences for a single functionality program
  19. Reliability via N-version programming?
  20. Specification based programming
  21. Waiting times and the task selection process
  22. Projects are worked on in fits and starts
  23. Answering via a scale to improve estimation accuracy
  24. Estimating Open source project lifecycle using the Bass model
  25. Software task estimation using LLMs is fake research
  26. Taking a new GLR parser generator for a spin
  27. Working with an LLM maths assistant to model software processes
  28. Predicting reports of new faults by counting past reports
  29. Advertised prices of desktop computers during the 1990s
  30. Maximum Adds per second for 1950s/early 1960s computers
  31. Chinese research in software engineering
  32. 70% of new software engineering papers on arXiv are LLM related
  33. Identifier names chosen to hold the same information
  34. Analysis of some C/C++ source file characteristics
  35. Relative performance of computers since the 1990s
  36. Investigating an LLM generated C compiler
  37. Algorithm complexity and implementation LOC
  38. Dennard scaling a necessary condition for Moore’s law
  39. Public documents/data on the internet sometimes disappears
  40. Number of calls to/from functions vs function length
  41. Formal methods and LLM generated mathematical proofs
  42. Distribution of small project completion times
  43. Modelling time to next reported fault

2025 52

  1. My 2025 in software engineering
  2. Programming Punched card machines
  3. Naming convergence in a network of pairwise interactions
  4. Christmas books for 2025
  5. Lifetime of coding mistakes in the Linux kernel
  6. Decline in downloads of once popular packages
  7. Occurrence of binary operator overloading in C++
  8. Fifth anniversary of Evidence-based Software Engineering book
  9. Best tool for measuring lots of source code
  10. Distribution of method chains in Java and Python
  11. Finding links between gcc source code and the C Standard
  12. Modeling the distribution of method sizes
  13. Early research on economies of scale for computer systems
  14. Data+code for book: The New C Standard
  15. Distribution of integer literals in text/speech and source code
  16. ISO C++ committee has a new chief sheep herder
  17. Percentage of methods containing no reported faults
  18. Halstead/McCabe: a complicated formula for LOC
  19. Half-life of Open source research software projects
  20. Positive and negative descriptions of numeric data
  21. Predicted impact of LLM use on developer ecosystems
  22. Impact of developer uncertainty on estimating probabilities
  23. A process to find and extract data-points from graphs in pdf files
  24. After 55.5 years the Fortran Specialist Group has a new home
  25. Why is actual implementation time often reported in whole hours?
  26. When task time measurements are not reported by developers
  27. An attempt to shroud text from LLMs
  28. Evolution has selected humans to prefer adding new features
  29. ClearRoute x Le Mans 24h Hackathon 2025
  30. One code path dominates method execution
  31. The inconvenient history of Liberal Fascism
  32. A safety-critical certification of the Linux kernel
  33. Software_Engineering_Practices = Morals+Theology
  34. Long term growth of programming language use
  35. Deciding whether a conclusion is possible or necessary
  36. CPU power consumption and bit-similarity of input
  37. Procedure nesting a once common idiom
  38. Functions reduce the need to remember lots of variables
  39. Remotivating data analysed for another purpose
  40. Benchmarking string search algorithms
  41. Half-life of Microsoft products is 7 years
  42. How has the price of a computer changed over time?
  43. CPU frequency not relevant to SPEC benchmark performance
  44. Repo of software estimation datasets
  45. Deep dive looking for good enough reliability models
  46. Zig is the next fashionable language
  47. Apollo guidance computer software development process
  48. Creating a global Standard requires being politically neutral
  49. Comparing developer/LLM coding performance
  50. Example of an initial analysis of some new NASA data
  51. Extracting information from duplicate fault reports
  52. Changing development culture and practices: LLM edition

2024 52

  1. My 2024 in software engineering
  2. Small business programs: A dataset in the research void
  3. Good enough reliability models: still an unknown
  4. Christmas books for 2024
  5. 21 Algol 60 compilers in 1962
  6. The Norden-Rayleigh model: some history
  7. Putnam’s software equation debunked
  8. Indented vs non-indented if-statements: performance difference
  9. Employment in the software business: we know nothing
  10. C compiler conformance testing: with ChatGPT assistance
  11. Modelling estimate/actual including uncertainty in the estimate
  12. if statement conditions, some basic measurements
  13. MC/DC a step towards safety critical Open source software
  14. Modeling program LOC growth with recurrence equations
  15. Discussing new language features is more fun than measuring feature usage in code
  16. Number of statement sequences possible using N if-statements
  17. Measuring non-determinism in the Linux kernel
  18. Survival of CVEs in the Linux kernel
  19. 1970s: the founding decade of software reliability research
  20. The units of measurement for software reliability
  21. Student projects for 2024/2025
  22. Memory bandwidth: 1991-2009
  23. The 2024 update to my desktop system
  24. A new NASA software dataset from the 1970s
  25. Program fault reports are caused by its users
  26. Confidence intervals: my one recommended practice
  27. Techniques used for analyzing basic performance measurements
  28. Learning General relativity at a rudimentary mathematical level
  29. Distribution of program sizes
  30. Quantity of source in a given language
  31. Obtaining source code for training LLMs
  32. Sampling error in software engineering
  33. A surprising retrospective task estimation dataset
  34. Workshop on data analysis for software developers
  35. Survey papers: LLMs will restore some level of usefulness
  36. Chinchilla Scaling: A replication using the pdf
  37. Relative sizes of computer companies
  38. Average lines added/deleted by commits across languages
  39. Software companies in the UK
  40. Census of general purpose computers installed in the 1960s
  41. A paper to forget about
  42. Finding reports and papers on the web
  43. What is known about software effort estimation in 2024
  44. The Whitehouse report on adopting memory safety
  45. Extracting named entities from a change log using an LLM
  46. A distillation of Robert Glass’s lifetime experience
  47. Some information on story point estimates for 16 projects
  48. Why did organizations fund the creation of the first computers?
  49. Agile and Waterfall as community norms
  50. How did Agile become the product development zeitgeist?
  51. Median system cpu clock frequency over last 15 years
  52. Documentation as a signal of program size

2023 53

  1. My 2023 in software engineering
  2. Sample size needed to compare performance of two languages
  3. Patches for the code of Peter Turchin’s Attrition Warfare Model
  4. Christmas books for 2023
  5. Software engineering’s F word
  6. Rounding in reported task implementation time
  7. Rereading The Mythical Man-Month
  8. Analyzing mainframe data in light of the IBM antitrust cases
  9. Evidence-based Software Engineering book: the last year
  10. Relative performance of computers from the 1950s/60s/70s
  11. Design of the Whetstone benchmark
  12. Likelihood of encountering a given sequence of statements
  13. Criteria for increased productivity investment
  14. Hardware/Software cost ratio folklore
  15. LLMs and doing software engineering research
  16. Some data on the size of Cobol programs/paragraphs
  17. Optimal function length: an analysis of the cited data
  18. Halstead & McCabe metrics: The wisdom of the ancients
  19. Readability of anonymous inner classes and lambda expressions
  20. Local variable naming: some previously unexplored factors
  21. Motivation and software development
  22. Accuracy of Function Point estimates
  23. Who are the famous academics in software engineering?
  24. Benchmarking fuzzers
  25. Research ideas for 2023/2024
  26. The lifetime of performance coding issues
  27. Predicting the size of the Linux kernel binary
  28. Anthropology and building software systems
  29. WebAssembly vs JavaScript performance: 2023 edition
  30. Perturbed expressions may ‘recover’
  31. Distribution of add/multiply expression values
  32. An evidence-based software engineering book from 2002
  33. von Neumann’s deduction that biological reproduction is digital
  34. Conference vs Journal publication
  35. The difference is significant
  36. Computer: Plot the data
  37. Is the code reuse problem now solved?
  38. Distribution of binary operator results
  39. How much productive work does a developer do?
  40. Percolation of the impact of coding mistakes through a program
  41. Analysis of when refactoring becomes cost-effective
  42. My new laptop
  43. Modular Reasoning, Knowledge and Language systems
  44. 2023 in the programming language standards’ world
  45. Small team estimating in story points; a project dataset
  46. Human reasoning is generally not logic based
  47. Software engineering as a hedonistic activity
  48. Many Butterfly collections are worthless
  49. A comparison of C++ and Rust compiler performance
  50. Frequency of non-linear relationships in software engineering data
  51. Coding mistakes made by ChatGTP
  52. Evaluating Story point estimation error
  53. Focus of activities planned for 2023

2022 54

  1. The commercial incentive to intentionally train AI to deceive us
  2. My 2022 search for software engineering data
  3. Analysis of Cost Performance Index for 338 projects
  4. Christmas books for 2022
  5. C++ deprecates some operations on volatile objects
  6. Unneeded requirements implemented in Waterfall & Agile
  7. Stochastic rounding reemerges
  8. Some human biases in conditional reasoning
  9. Evidence-based Software Engineering book: two years later
  10. A study of deceit when reporting information in a known context
  11. Studying the lifetime of Open source
  12. Clustering source code within functions
  13. Printing press+widespread religious behavior: A theory
  14. Shopper estimates of the total value of items in their basket
  15. Overview of broad US data on IT job hiring/firing and quitting
  16. Optimal sizing of a product backlog
  17. Career progression: an invisible issue in software development
  18. Programming Languages: History and Fundamentals
  19. Task backlog waiting times are power laws
  20. Patterns in the LSST:DM Sprint/Story-point/Story ‘done’ issues
  21. Impact of number of files on number of review comments
  22. Analysis of a subset of the Linux Counter data
  23. Estimation accuracy in the (building|road) construction industry
  24. Evolution of the DORA metrics
  25. Extracting numbers from a stacked density plot
  26. Multi-state survival modeling of a Jira issues snapshot
  27. Estimating quantities from several hundred to several thousand
  28. Most percentages are more than half
  29. Over/under estimation factor for ‘most estimates’
  30. A Wikihouse hackathon
  31. Cognitive effort, whatever it might be
  32. Rounding and heaping in non-software estimates
  33. Complex software makes economic sense
  34. A new career in software development: advice for non-youngsters
  35. Evaluating estimation performance
  36. Twitter and evidence-based software engineering
  37. Evidence-based Software Engineering: now in paperback form
  38. Programming language similarity based on their traits
  39. Ecology as a model for the software world
  40. NoEstimates panders to mismanagement and developer insecurity
  41. 4,000 vs 400 vs 40 hours of software development practice
  42. Anthropological studies of software engineering
  43. Study of developers for the cost of a phase I clinical drug trial
  44. Growth in FLOPs used to train ML models
  45. Cost-effectiveness decision for fixing a known coding mistake
  46. Software engineering research is a field of dots
  47. Estimation experiments: specification wording is mostly irrelevant
  48. semgrep: the future of static analysis tools
  49. Finding patterns in construction project drawing creation dates
  50. Moore’s law was a socially constructed project
  51. Including natural language text topics in a regression model
  52. Tracking software evolution via its Changelog
  53. Join a crowdsourced search for software engineering data
  54. Creating and evolving a programming language: funding

2021 54

  1. Fishing for software data
  2. Christmas books for 2021
  3. Parkinson’s law, striving to meet a deadline, or happenstance?
  4. First understand the structure of a standard, then read it
  5. The software heritage of K&R C
  6. Open source: the goody bag for software infrastructure
  7. Where are we with models of human learning?
  8. How large an impact does social conformity have on estimates?
  9. Academic recognition for creating and supporting software
  10. Evidence-based SE groups doing interesting work, 2021 version
  11. Looking for a measurable impact from developer social learning
  12. Two failed software development projects in the High Court
  13. Electronic Evidence and Electronic Signatures: book
  14. The Approximate Number System and software estimating
  15. The Shape of Code is moving
  16. Mutation testing: its days in the limelight are over
  17. Testing rounded data for a circular uniform distribution
  18. Multiple estimates for the same project
  19. Readability: a scientific approach
  20. Cognitive bias or not paying enough attention?
  21. Actual implementation times are often round numbers
  22. What can be learned from studying long gone development practices?
  23. 2021 in the programming language standards’ world
  24. Estimating using a granular sequence of values
  25. What is known about software effort estimation in 2021
  26. Production of software may continue to be craft based
  27. Increase in defect fixing costs with distance from original mistake
  28. Evidence-based book: six months of downloads
  29. The CESAW dataset: a brief introduction
  30. Impact of native language on variable naming
  31. Pomodoros worked during a day: an analysis of Alex’s data
  32. Where are the industrial strength R compilers?
  33. Delphi and group estimation
  34. Estimate variability for the same task
  35. Claiming that software is AI based is about to become expensive
  36. Software engineering experiments: sell the idea, not the results
  37. Another nail for the coffin of past effort estimation research
  38. Pricing by quantity of source code
  39. The first computer I owned
  40. Linux has a sleeper agent working as a core developer
  41. The aura of software quality
  42. Software engineering research problems having worthwhile benefits
  43. The impact of believability on reasoning performance
  44. Code bureaucracy can reduce the demand for cognitive resources
  45. Fitting discontinuous data from disparate sources
  46. Research software code is likely to remain a tangled mess
  47. Performance impact of comments on tasks taking a few minutes
  48. Widely used programming languages: past, present, and future
  49. Growth in number of packages for widely used languages
  50. Payback time-frame for research in software engineering
  51. Software effort estimation is mostly fake research
  52. My new kitchen clock
  53. Likelihood of a fault experience when using the Horizon IT system
  54. What impact might my evidence-based book have in 2021?

2020 51

  1. Source code discovery, skipping over the legal complications
  2. Many coding mistakes are not immediately detectable
  3. Survival rate of WG21 meeting attendance
  4. Christmas books for 2020
  5. Software research is 200 years behind biology research
  6. What software engineering data have I collected on subject X?
  7. Researching programming languages
  8. Evidence-based software engineering: book released
  9. The Weirdest people in the world
  10. Benchmarking desktop PCs circa 1990
  11. Learning useful stuff from the Human cognition chapter of my book
  12. Learning useful stuff from the Cognitive capitalism chapter of my book
  13. Memory capacity growth: a major contributor to the success of computers
  14. Learning useful stuff from the Ecosystems chapter of my book
  15. Learning useful stuff from the Projects chapter of my book
  16. Learning useful stuff from the Reliability chapter of my book
  17. Impact of function size on number of reported faults
  18. The aims of software engineering research
  19. Time-to-fix when mistake discovered in a later project phase
  20. Quality control in a zero cost of replication business
  21. Extreme value theory in software engineering
  22. Scientific management of software production
  23. Surveys are fake research
  24. Effort estimation’s inaccurate past and the way forward
  25. No replies to 135 research data requests: paper titles+author emails
  26. Algorithms are now commodities
  27. beta: Evidence-based Software Engineering – book
  28. How should involved if-statement conditionals be structured?
  29. An experiment involving matching regular expressions
  30. C++ template usage
  31. Estimating in round numbers
  32. New users generate more exceptions than existing users (in one dataset)
  33. Happy 60th birthday: Algol 60
  34. Having all the source code in one file
  35. Enthusiasm on the Fortran standards committee
  36. Beta release of data analysis chapters: Evidence-based software engineering
  37. Predicting the future with data+logistic regression
  38. Motzkin paths and source code silhouettes
  39. Comments on the COVID-19 model source code from Imperial
  40. Influential programming languages: some of the considerations
  41. Coronavirus: a silver lining for evidence-based software engineering?
  42. Exercises in Programming Style: the python way
  43. Source code chapter of ‘evidence-based software engineering’ reworked
  44. The wisdom of the ancients
  45. Patterns of regular expression usage: duplicate regexs
  46. Source code has a brief and lonely existence
  47. How are C functions different from Java methods?
  48. How useful are automatically generated compiler tests?
  49. for-loop usage at different nesting levels
  50. The dark-age of software engineering research: some evidence
  51. Performance variation in 2,386 ‘identical’ processors

2019 54

  1. Reliability chapter of ‘evidence-based software engineering’ updated
  2. The Renzo Pomodoro dataset
  3. Calculating statement execution likelihood
  4. Christmas books for 2019
  5. A study, a replication, and a rebuttal; SE research is starting to become serious
  6. Design considerations for Mars colony computer systems
  7. Adjectives in source code analysis
  8. Student projects for 2019/2020
  9. Projects chapter of ‘evidence-based software engineering’ reworked
  10. Three books discuss three small data sets
  11. Comparing expression usage in mathematics and C source
  12. Cost ratio for bespoke hardware+software
  13. C compilers on PR1ME computers
  14. Plotting artifacts when the axis involves lines of code
  15. Team DNA-impersonators create a business plan
  16. Natural elimination, or the survival of the good enough
  17. Ecosystems chapter of “evidence-based software engineering” reworked
  18. Compiler validation used to be a big thing
  19. Converting lines in an svg image to csv
  20. My book’s pdf generation workflow
  21. Growth and survival of gcc options and processor support
  22. First language taught to undergraduates in the 1990s
  23. Want to be the coauthor of a prestigious book? Send me your bid
  24. 2019 in the programming language standards’ world
  25. Complexity is a source of income in open source ecosystems
  26. How much is a 1-hour investment today worth a year from now?
  27. Medieval guilds: a tax collection bureaucracy
  28. A zero-knowledge proofs workshop
  29. Lehman ‘laws’ of software evolution
  30. PCTE: a vestige of a bygone era of ISO standards
  31. Cognitive capitalism chapter reworked
  32. Evidence on the distribution and diversity of Christianity: 1900-2000
  33. Background checks on pointer values being considered for C
  34. A prisoner’s dilemma when agreeing to a management schedule
  35. C Standard meeting, April-May 2019
  36. Dimensional analysis of the Halstead metrics
  37. C2X and undefined behavior
  38. OSI licenses: number and survival
  39. The Algorithmic Accountability Act of 2019
  40. MI5 agent caught selling Huawei exploits on Russian hacker forums
  41. The 2019 Huawei cyber security evaluation report
  42. Using Black-Scholes in software engineering gives a rough lower bound
  43. Describing software engineering in terms of a traditional science
  44. Altruistic innovation and the study of software economics
  45. Regression line fitted to noisy data? Ask to see confidence intervals
  46. Polished human cognitive characteristics chapter
  47. Modular vs. monolithic programs: a big performance difference
  48. Evidence-based election campaigning
  49. Offer of free analysis of your software engineering data
  50. Modeling visual studio C++ compile times
  51. Teaching basic data analysis to programmers: summer internship
  52. Choosing between two reasonably fitting probability distributions
  53. Wanted: 99 effort estimation datasets
  54. Changes in the shape of code during the twenties?

2018 70

  1. Foundations for Evidence-Based Policymaking Act of 2017
  2. Distorting the input profile, to stress test a program
  3. Growth of conditional complexity with file size
  4. Impact of group size and practice on manual performance
  5. Coding guidelines should specify what constructs can be used
  6. The 520’th post
  7. Half-life of software as a service, services
  8. Ecosystems as major drivers of software development
  9. Polished statistical analysis chapters in evidence-based software engineering
  10. Waiting for the funerals: culture in software engineering research
  11. Some pair programming benefits may be mathematical artefacts
  12. Christmas books for 2018
  13. Is it worth attending an academic conference or workshop?
  14. Practical ecosystem books for software engineers
  15. Practical psychology books for software engineers
  16. Practical statistics books for software engineers
  17. The first commercially available (claimed) verified compiler
  18. Publishing information on project progress: will it impact delivery?
  19. Statistical techniques not needed to analyze software engineering data
  20. Students vs. professionals in software engineering experiments
  21. The best or most compiler writers born in February?
  22. Facebook’s Big Code Summit
  23. Adding a new scalar type to C
  24. The Nostradamus argument in software engineering research
  25. The world view of research in software engineering
  26. A 1948 viewpoint on developer vs. computer time
  27. Major players in evidence-based software engineering
  28. Business school research in software engineering is some of the best
  29. Moving to the 12th cycle in fault prediction modeling
  30. Grammar checking in 2018
  31. Experimental Psychology by Robert S. Woodworth
  32. Impact of team size on planning, when sitting around a table
  33. 2018 in the programming language standards’ world
  34. Maximum team size before progress begins to stall
  35. StatsModels: the first nail in R’s coffin
  36. What statistical techniques are useful for software engineering data?
  37. Source code chapter added to “Evidence-based software engineering using R”
  38. Perl’s failure to grow and Python takes over
  39. Evolutionary pressures on C++, Java and Python
  40. Filters to help decide who might be a software developer
  41. Instructions that cpus don’t need to support
  42. Software engineering is fertile ground for the belief in silver bullets
  43. Time taken to compile a source file
  44. Undergraduates and learning to program
  45. Number of parameters vs. accessing globals
  46. Main memory: the crucial component that vendors don’t mention
  47. EDG and Github are both logical purchases for Microsoft
  48. The age of the Algorithm is long gone
  49. Premium mediocrity is software engineering’s demographic
  50. Replicating results using research software
  51. Type compatibility: name vs structural equivalence
  52. Replication: not always worth the effort
  53. A Python Data Science hackathon
  54. Influential philosophers of source code
  55. The C++ committee has taken off its ball and chain
  56. GDPR has a huge impact on empirical software engineering research
  57. Reliability chapter added to “Empirical software engineering using R”
  58. McCabe’s cyclomatic complexity and accounting fraud
  59. Top, must-read paper on software fault analysis
  60. Estimating the number of distinct faults in a program
  61. Historians of computing
  62. Building a regression model is easy and informative
  63. Statement sequence length for error/non-error paths
  64. Mathematical proofs contain faults, just like software
  65. Compiler validation is now part of history
  66. What instructions should a computer support?
  67. Learning a cpu’s instruction set
  68. First use of: software, software engineering and source code
  69. Computer books your great grandfather might have read
  70. Was a C90, C99, or C11 compiler used?

2017 60

  1. Almost all published analysis of fault data is worthless
  2. The first compiler was implemented in itself
  3. The shadow of the input distribution
  4. Christmas books for 2017
  5. ISO/IEC JTC 1/SC 42 Artificial intelligence
  6. Vanity project or real research?
  7. Data-set update to “Empirical software engineering using R”
  8. Grace Hopper: Manager, after briefly being a programmer
  9. À la carte Entropy
  10. Double exponential performance hit in C# compiler
  11. Huge effort data-set for project phases
  12. Projects chapter added to “Empirical software engineering using R”
  13. Is this fitted line believable? A visual answer
  14. Data analysis with a manual mindset
  15. Histogram using log scale creates a visual artifact
  16. Expected variability in a program’s SLOC
  17. Experimental method for measuring benefits of identifier naming
  18. An Almanac of the Internet
  19. Investing in the gcc C++ front-end
  20. The fuzzy line between reworking and enhancing
  21. Microcomputers ‘killed’ Ada
  22. We hereby retract the content of this paper
  23. Two approaches to arguing the 1969 IBM antitrust case
  24. Books similar to my empirical software engineering book
  25. Signed-magnitude: The integer representation of choice for IoT?
  26. Software systems are the product of cognitive capitalism
  27. Ecosystems chapter added to “Empirical software engineering using R”
  28. 2017 in the programming language standards’ world
  29. Information on computers from the 1970s and earlier
  30. Increase your citation count, send me your data!
  31. Whole-program optimization: there’s gold in them hills
  32. How indeterminate is an indeterminate value?
  33. Experiment, replicate, replicate, replicate,…
  34. Unappreciated bubble research
  35. Signaling cognitive firepower as a software developer
  36. Burger flippers with STEM degrees
  37. Evidence for 28 possible compilers in 1957
  38. Programming Languages: nothing changes
  39. What is empirical software engineering?
  40. Warp your data to make it visually appealing
  41. Array bound checking in C: the early products
  42. Hedonism: The future economics of compiler development
  43. Average maintenance/development cost ratio is less than one
  44. Early compiler history
  45. Collecting all of the publicly available source code
  46. Gentleman scientists in software engineering
  47. Economics chapter added to “Empirical software engineering using R”
  48. Happy 30th birthday to GCC
  49. Learning from some legal decisions
  50. Uncovering the undefined behaviors
  51. C compilers of the 20th century running on Microsoft operating systems
  52. Estimating the yearly spend on developing software
  53. NWIP for Monochrome inkjet yield
  54. DACS: Software Life Cycle Empirical/Experience Database
  55. Fault density: so costly to calculate that few values are reliable
  56. I have been reading your interesting paper
  57. Empirical Software Engineering using R: first draft available for download
  58. Full Fact checking of number words
  59. The future evolutionary cycle of application software?
  60. Understanding where one academic paper fits in the plot line

2016 52

  1. Failed projects + the Cloud = Software reuse
  2. Is sorting a list of names racial discrimination?
  3. Automatically generated join-the-dots images
  4. Christmas books for 2016
  5. Giving engineers the freedom to create a customer lock-in Cloud
  6. Ability to remember code improves with experience
  7. Power law of practice in software implementation
  8. Uncertainty in data causes inconsistent models to be fitted
  9. Pre-Internet era books that have not yet been bettered
  10. Producing software for money and/or recognition
  11. Software architect is an illegal job title in the UK
  12. A signature for the “embeddedness” of source code and developers?
  13. Fortran 2008 Standard has been updated
  14. Student projects for 2016/2017
  15. Does public disclosure of vulnerabilities improve vendor response?
  16. The wind is not yet blowing in software engineering research
  17. Converting between IFPUG & COSMIC function point counts
  18. p-values in software engineering
  19. Software engineering data sets
  20. Does using formal methods mean anything?
  21. ‘to program’ is 70 this month
  22. ALGEC: ALGorithmic language for EConomic problems
  23. Happy 10th birthday to CREST
  24. Fortran & Cobol in the USAF over the years 1955-1986
  25. Is the ISO C++ standard’s committee past its sell by date?
  26. AEC hackathon: what do the coloured squiggles mean?
  27. When will Microsoft stop bothering to sell compilers?
  28. Least Recently Used: The experiment that made its reputation
  29. GitHub, the logical next purchase for Microsoft after LinkedIn
  30. Finding the gold nugget papers in software engineering research
  31. Predicting the next value in an integer sequence
  32. The fall of Rome and the ascendancy of ego and bluster
  33. Software Reliability: Lots of detailed data and thoughtful analysis
  34. COCOMO: Not worth serious attention
  35. Applied Software Measurement: shame about the made up numbers
  36. Survival time of Linux distributions
  37. Cost/performance analysis of 1944-1967 computers: Knight’s data
  38. Explaining the decline of German comments in LibreOffice
  39. The dance of the dead cat
  40. C Standard meeting, April 2016
  41. Tools that help handle floating-point dragons
  42. Ada updated to support undefined behavior
  43. Habits are the peripheral vision of the mind
  44. cpu+FPGA: applications can soon have bespoke instructions
  45. A survey of opinions on the behavior of various C constructs
  46. p-values for programmers
  47. Workshop on survival and time series analysis in empirical SE
  48. pycparser: a serious entry in the not-written-in-C C-parser category
  49. Human vs automatically generated source code: an arms race?
  50. Maximizing profit selling C compilers
  51. A book of wrongheadedness from O’Reilly
  52. subset vs array indexing: which will cause the least grief in R?

2015 56

  1. R recommended usage for professional developers
  2. 2015: the year I started regularly talking to researchers in China
  3. Christmas books: 2015
  4. So you found a bug in my compiler: Whoopee do
  5. Hackathon New Year’s resolution
  6. Machine learning in SE research is a bigger train wreck than I imagined
  7. The Empirical Investigation of Perspective-Based Reading: Data analysis
  8. Peak memory transfer rate is best SPECint performance predictor
  9. Word length lexical decision data
  10. Operator assignment may be in the next Ada standard
  11. Researching just to create software patents
  12. Lisp and functional languages discourage free riders
  13. Citation patterns in my two books
  14. Forces driving patterns found in call graphs of human written code
  15. Workshop on analyzing software engineering data
  16. The Ockham Sound Analysis Criteria
  17. Recent formal methods and C papers (Sep 2015)
  18. The compiler/interpreter distinction
  19. Actively maintained production compilers for middle-age languages
  20. Eye-tracking of developers reading code is now in start-up mode
  21. 2015 in the programming language standard’s world
  22. Adding house numbers to Open Street Map
  23. How will C code in 2045 look different from today?
  24. A first stab a low resolution image enhancement
  25. Deluxe Paint: 30 year old C showing its age in places
  26. Exhuastive superoptimization
  27. R is now important enough to have a paid for PR make-over
  28. 2015: A new C semantics research group
  29. High value IP auctions, finally a way to moneterise the blockchain
  30. Extracting absolute values from percentage data
  31. Power consumed by different instruction operand value pairs
  32. Is your interesting project on hold because of lack of sufficient cpu time?
  33. Aggregate player preference for the first 20 building created in Illyriad
  34. Source code usage via n-gram analysis
  35. Joke: Student subjects in software engineering experiments
  36. Finding team members and an idea at a hackathon
  37. Finding and choosing a hackathon to attend
  38. Debian has cast iron rules for package growth & death
  39. Computing academics destined to remain software engineering virgins
  40. R’s plot function, the 1970’s retro look is not cool any more
  41. Semantic vs phonetic similarity for word pairs: a weekend investigation
  42. A disheartening Space Apps hackathon
  43. Entropy: Software researchers go to topic when they have no idea what else to talk about
  44. Coq used to prove that false is true
  45. C code is 90% unspecified behavior: more uninformed scare mongering
  46. Ethereum: Is it cost effective to create reliable contracts?
  47. Been invaded by mysterious sounds? You need SoundHound
  48. Extracting the original data from a heatmap image
  49. Hardware variability may be greater than algorithmic improvement
  50. Long tail licensing
  51. Do languages evolve to minimise portability?
  52. Top secret free information
  53. Live coding, where should I send my invoice for performance royalties?
  54. My 2cents on the design of the contract language in Ethereum
  55. Ethereum contracts, is the design viable?
  56. Users of Open source software are either the product or are irrelevant

2014 64

  1. Z and Zermelo–Fraenkel
  2. XSLT, yacc and Yorick
  3. Wolfram and Whitespace
  4. VHDL, Visual-Basic and VDM
  5. UNCOL and UML
  6. TECO, Tcl/Tkl and TeX
  7. Snobol 4, Simula 67, Smalltalk, sed, SQL, SETL, Scratch and Spreadsheet
  8. Ratfor, R, RUNOFF, RPG and Ruby
  9. Qcl
  10. Pascal, Prolog, Perl, Python and PL/1
  11. Occam, Oberon, Objective-C and OCaml
  12. NATURAL, NewSpeak and NetLogo
  13. Modula-2, ML, M4, MUMPS and Miranda
  14. Lisp, Logo, LaTeX and Lua
  15. KRL and the K semantic-framework
  16. Jovial, JCL, Java and Javascript
  17. INTERCAL and Icon
  18. Haskell, HTML and Hack
  19. GPSS and Go
  20. Fortran, Forth, Frink and Flow
  21. Eiffel, English and Erlang
  22. Dylan, D and Dart
  23. Coral 66, CHILL, C, Cobol and C++
  24. BASIC, Babbage, BCPL, B, BLISS and BLooP
  25. ALGOL 60, AWK, ALGOL 68, Ada, APL and Assembler
  26. Empirical analysis of UK legislation started this weekend
  27. Cobol 2014, perhaps the definitive final version of the language…
  28. The POPL 2015 papers involving C
  29. Workshop on App Store Analysis
  30. Predicting stuff involving the next hour of my life
  31. Running Average Power Limit: a new target for viruses
  32. A book about some important bits of R
  33. Creating a map showing land covered by rising sea levels
  34. Is Earley parsing now practical?
  35. undefined behavior: pay up or shut up
  36. Self-driving cars, is it safer on the inside or the outside?
  37. Evidence for the benefits of strong typing, where is it?
  38. C++14 is now in, C++11 is out and C++17 is on the horizon
  39. Success: Software engineering data is starting to become very dull
  40. An ISO Standard for R (just kidding)
  41. My first day developing for Google Glass
  42. Reality in the world of programming language standards
  43. How to avoid being a victim of Brooks’ law
  44. Compiler writing is for hedgehogs
  45. Agile and the sound of one hand clapping
  46. Socrates 2014 unconference in the UK
  47. Source code will soon need to be radiation hardened
  48. Oh, I did not know that [about R]
  49. APIs can, for the time being, be copyrighted
  50. MyFloodPlan: The personalized flood plan App
  51. C++ vs. Ada: Which language is more strongly typed?
  52. The Shattered Windows App: How much will an asteroid impact cost you?
  53. Heartbleed: Critical infrastructure open source needs government funding
  54. A trip down memory lane with Microsoft Word 1.1
  55. Hack, a template for improving code reliability
  56. By now I ought to feel more knowledgeable about R
  57. Open source: monoculture is more desirable than portability
  58. Performing a non-local return in R
  59. Prompt Parking near Buckingham Palace
  60. Adverts during compilation; the future for gcc and llvm?
  61. Honking the horn for go faster memory (over go faster cpus)
  62. Tool for tuning the use of floating-point types
  63. Changes in the API/non-API method call ratio with program size
  64. A prediction for 2014

2013 45

  1. Converting graphs in pdf files to csv format
  2. Variable naming based on lengths of existing variable names
  3. How to use intellectual property tax rules to minimise corporation tax
  4. Unreliable cpus and memory: The end result of Moore’s law?
  5. Street cred has no place in guidelines for nuclear power stations
  6. Ordinary Least Squares is dead to me
  7. R now has its own shelf in Dillons
  8. What is the error rate for published mathematical proofs?
  9. Testing compiler semantics with minimal manual input
  10. Ways of obtaining empirical data in software engineering
  11. Programming using genetic algorithms: isn’t that what humans already do ;-)
  12. Single-quote as a digit separator soon to be in C++
  13. How many ways of programming the same specification?
  14. Software engineering: A great discipline for an academic fraudster
  15. 2013 in the programming language standards’ world
  16. Cloning research needs a new mantra
  17. A local CS reading group
  18. I made a mistake, please don’t shoot me
  19. Amount of end-user usage of code in Firefox
  20. Unique bytes in a sliding window as a file content signature
  21. Free range software developers: Are they cost effective?
  22. Empirical SE groups doing interesting work, 2013 version
  23. Survey of instruction selection
  24. Apps in Space Hackathon
  25. Hiring experts is cheaper in the long run
  26. Data cleaning: The next step in empirical software engineering
  27. Arm waver or expert?
  28. Preferential attachment applied to frequency of accessing a variable
  29. Wot, apply academic work in industry?
  30. Dead trees have been replaced by a paywall
  31. Prioritizing project stakeholders using social network metrics
  32. Spreadsheet errors: open source or survival of the fittest
  33. Never too experienced to make a basic mistake
  34. Push hard on a problem here and it might just pop up over there
  35. More men than women are incompetent/very competent
  36. R needs some bureaucracy
  37. Verified compilers and soap powder advertising
  38. The most worthwhile R coding guidelines I know
  39. Does native R usage exist?
  40. Will incorrect answers be biased towards one arm of an if-statement?
  41. Will programming languages now have to follow ISO fast-track rules?
  42. Popularity of Open source Operating systems over time
  43. Only compiler vendor customers, not its users, count
  44. US DoD software development data now available
  45. Programs spent a lot of time repeating themselves

2012 52

  1. Telepathic communication with a Supreme Being
  2. Low defect density implies climate code less, not more, reliable
  3. My R naming nemesis
  4. Distribution of uptimes for high-performance computing systems
  5. Proposal for a change of approach to programming language teaching
  6. Most developers don’t really know any computer language
  7. Superoptimizers are back in vogue
  8. Why is Cobol still popular in Japan?
  9. Sampling is now an issue in software engineering research
  10. Break even ratios for development investment decisions
  11. Agreement between code readability ratings given by students
  12. Sequence generation with no duplicate pairs
  13. Transition probabilities when adjacent sequence items must be different
  14. Impact of compiler optimization level on recovery from a hardware error
  15. Teach children planning and problem solving not programming
  16. Changes in optimization performance of gcc over time
  17. Descriptive statistics of some Agile feature characteristics
  18. The oldest compiler still in production use is?
  19. Writing language standards is a cottage industry
  20. My no loops in R hair shirt
  21. Success does not require understanding
  22. Why does Coverity restrict who can see its tool output?
  23. Undefined behavior can travel back in time
  24. Ternary radix will have to wait for photonic computers
  25. Impact of hardware characteristics on detectable fault behavior
  26. Trying to sell analysis tools to the Nuclear Regulatory Commission
  27. Background to my book project “Empirical Software Engineering with R”
  28. Maths GCE from 1972 (paper 2)
  29. Automatically generating railroad diagrams from yacc files
  30. Why do companies fix faults in software they sell?
  31. Would you buy second hand software from a formal methods researcher?
  32. Undefined behavior is a design decision
  33. EU rules that computer languages cannot be copyrighted
  34. Incompetence borne of excessive cleverness
  35. An academic programming language paper about R
  36. Using identifier prefixes results in more developer errors
  37. Randomizing a list of items using sort() and rand()
  38. A free pdf that is not the C++ Standard
  39. Generating code that looks like it is human written
  40. Unique values generated by expressions of a given complexity
  41. Go faster R for Google’s summer of code 2012
  42. Matching context sensitive rules and generating output using regular expressions
  43. Generating sounds-like and accented words
  44. The fatal programming language research mistake
  45. Parsing R code: Freedom of expression is not always a good idea
  46. Number of possible different one line programs
  47. Birth month for compiler writers
  48. February 2012 news in the programming language standard’s world
  49. O Cobol, Cobol! wherefore art thou Cobol?
  50. Correlation between risk attitude and willingness to refer back
  51. Relative spacing of operands affects perception of operator precedence
  52. Type compatibility the hard way

2011 38

  1. Initial impressions of RangeLab
  2. Licensing to decide the result of gcc vs llvm?
  3. Optimizing floating-point expressions for accuracy
  4. Christmas books for 2011
  5. Learning R as a language
  6. Software memory management
  7. Compiling to reduce the impact of soft errors on program output
  8. Abramowitz and Stegun mark II
  9. Predictive Modeling: 15th COW workshop
  10. What I know of Dennis Ritchie’s involvement with C
  11. Memory capacity and commercial compiler development
  12. Does the UK need the PL/1 Standard?
  13. Automatically improving code
  14. C compiler validation is 21 today!
  15. sparse can now generate executables
  16. Halstead’s metrics and flat-Earthers are still with us
  17. Ruby becoming an ISO Standard
  18. Estimating the reliability of compiler subcomponent
  19. Compiler benchmarking for the 21st century
  20. Quality of data analysis: two recent papers
  21. Readability: we know nothing
  22. Fibonacci and JIT compilers
  23. Developers do not remember what code they have written
  24. Searching for inaccurate literals in R
  25. Using evolution to reduce competition
  26. Fingerprinting the author of the ZeuS Botnet
  27. Unused function parameters
  28. Estimating the quality of a compiler implemented in mathematics
  29. Proving software correct
  30. Simple generator for compiler stress testing source
  31. Quality comparison of floating-point maths libraries
  32. Empirical software engineering is five years old
  33. A change of guard in the C standard’s world?
  34. Hexadecimal usage in Google’s scanned books
  35. ISO Standards, the beauty and the beast
  36. SQL usage: schema evolution
  37. Program optimization given 1,000 datasets
  38. Language usage in Google’s ngram viewer

2010 33

  1. Has the seed that gets software development out of the stone-age been sown?
  2. Christmas book for 2010
  3. Build an ISO Standard and the world will beat a path to your door
  4. C is top dog in Google AI Challenge
  5. Flawed analysis of “one child is a boy” problem?
  6. Ordering of members in Oracle/Google Java copyright lawsuit
  7. Language vulnerabilities TR published
  8. Predictor vs. control metrics
  9. So what if it is undecidable or NP!
  10. Thinking in R: vectors
  11. Oracle/Google ‘Java’ patents lawsuit
  12. Behavior patterns in Colonel Blotto
  13. Is unreachable code primarily created by a fault?
  14. Adding negative information to source
  15. Shell languages are probably a distinct category of computer language
  16. Two models of developer response to false positive warnings
  17. Network protocols also evolve into a tangle of dependencies
  18. Any technical benefits to C++ in a C project?
  19. GCC moves to attract more developers
  20. Frequency of floating literals in a given range
  21. Building directly from a .tgz file
  22. SEC wants prospectus source code to be published
  23. Brief history of syntax error recovery
  24. Number of digits in floating-point literals
  25. What language was an executable originally written in?
  26. Program analysis via information leakage
  27. Variations in the literal representation of Pi
  28. Using numeric literals to identify application domains
  29. Designing a processor for increased source portability costs
  30. Minimum information needed for writing a code generator
  31. Secret instruction sets about to make a come-back
  32. Assessing my predictions for 2009
  33. Why does Intel sell compilers?

2009 39

  1. The changing shape of code in the next decade
  2. The Met Office ‘climategate’ Perl code
  3. Compiler writing in the next decade
  4. Parsing Fortran 95
  5. Information content of expressions
  6. Christmas books for 2009
  7. Does the Climategate code produce reliable output?
  8. Software maintenance via genetic programming
  9. Where are the dead bodies?
  10. sizeof i++
  11. Compiler writing: The career path to World domination
  12. CPUs also exhibit hardware faults
  13. Estimating variance when measuring source
  14. Register vs. stack based VMs
  15. Using Coccinelle to match if sequences
  16. GLR parsing is the future
  17. To if-else-if or if-if, that is the question
  18. Implementing the between operation
  19. Searching for the source line implementing 3n+1
  20. Will language choice converge to a few?
  21. Dimensional analysis of source code
  22. Assuming compilers are clever enough (part 1)
  23. The complexity of three assignment statements
  24. Code generation via machine learning
  25. Finding the ‘minimum’ faulty program
  26. Parsing ambiguous grammars (part 1)
  27. volatile handling sometimes overly volatile
  28. A fault in the C Standard or existing compilers?
  29. Using third party measurement data
  30. Using local context to disambiguate source
  31. Measuring developer coding expertise
  32. The probability of encountering a given variable
  33. Readability, an experimental view
  34. Unexpected experimental effects
  35. The sound of code
  36. Incorrect spelling
  37. Semantic pattern matching (Coccinelle)
  38. What I changed my mind about in 2008
  39. The 30% of source that is ignored

2008 16

  1. Predictions for 2009
  2. Recommendations for teachers of programming
  3. Searching code for a specific kind of calculation
  4. Criteria for knowing a language
  5. Why is code so fault tolerant?
  6. Parsing without a symbol table
  7. Distribution of numeric values (additive)
  8. Benford’s law and numeric literals in source code
  9. How widely used is a language?
  10. C++ goes for too big to fail
  11. How not to treat loyal customers
  12. Naming used to predict object lifetime
  13. Monte Carlo arithmetic operations
  14. A power law artifact
  15. Average distance between two fields
  16. Will IEEE 754 become a fringe representation?