machine learning

Curvature Cryptanalysis of Smooth Transformer Feed-Forward Networks

We show that smooth two-layer feed-forward networks (FFNs) expose an additional structural model extraction channel under a chosen-input raw-output oracle at the FFN branch; consider transformer FFN branches with GELU or SiLU activations under chosen-input raw-output access, without access to parameters, gradients, or internal activations; exploit a second-order leakage channel in which projected input Hessians form different mixtures of the same hidden symmetric rank-one factors induced by the FFN input weights. We formalize resulting Hessian collection as a partially symmetric decomposition to establish conditions for local identifiability and stability to exploit vector-output stencil reuse to reduce the structural query cost by a factor of 16. On independently trained CIFAR-10 vision transformers, only 16 projected Hessians, corresponding to 8193 black-box queries, recover the hidden FFN directions with average absolute cosine alignment above 0.94, with 95.1 % of GELU and 91.9 % of SiLU directions exceeding 0.90 alignment. Recovery remains high across independently trained models, repeated extraction runs, and all transformer blocks. The recovered structure supports functional extraction too. Keeping the recovered directions fixed and fitting only the remaining FFN parameters yields high-fidelity substitutes with more than 93 % top-1 agreement, while test accuracy remains within 0.90% and 0.62% of the GELU and SiLU targets. Output rounding and Gaussian noise substantially reduce recovery under a fixed attack configuration, but adapting the finite-difference step restores average alignment to 0.9603 and 0.9398. This is an end-to-end path from black-box second-order observations to hidden FFN-structure recovery and functional replacement. Under the stated oracle model, smooth FFN curvature exposes internal parameter geometry that behavioral fidelity alone cannot reveal.

Unsupervised Latent Space Alignment with Hyperspherical Geodesic Matching

Independently trained neural networks tend to encode the same data with similar latent geometries. These latent geometries are not directly compatible, yet they can be nearly the same up to some class of transformations. While there exists many methods for alignment between different latent spaces, it is typically done using a set of shared sample correspondences, known as anchors. This leaves a fundamental question: are the geometric signatures of different latent spaces representing similar data sufficient to recover an alignment between them? To that end, we introduce HGA (Hyperspherical Gaussian Alignment), a method that directly optimizes a transformation between two latent spaces by maximizing a geometric measure of "fit" between them. Since it is driven by the geometry of the latent spaces rather than paired data, HGA can operate in both an unsupervised and weakly supervised regime. On tasks such as model stitching or multilingual word embedding correspondence recovery, HGA manages to match supervised results with minimal or no supervision.

ERR+: Sequential Entropy Resolution for Efficient and Decisive LLM Reasoning

Large reasoning models achieve strong performance on complex tasks by generating extended chain-of-thought (CoT) traces via reinforcement learning with verifiable rewards (RLVR). While current RLVR methods have achieved strong results with correctness-based reward signals, they provide limited guidance on the quality of the reasoning process itself, leaving the internal reasoning structure largely unoptimized. Through empirical analysis across multiple model families, we identify a consistent pattern: correct reasoning trac es exhibit more frequent and larger token-level entropy drops within the thinking phase than incorrect ones. We propose ERR+, a two-phase RLVR framework grounded in this observation. The first phase trains with the Entropy Relief Reward (ERR), a bonus proportional to cumulative token-level entropy drops in the thinking phase, log-normalized by response length. Unlike prior methods that suppress entropy, ERR rewards the resolution of uncertainty while leaving exploratory high-entropy states unconstrained. The second phase introduces the Robust Relative Efficiency Reward, which scores each response's length against co-generated peers via a $\tanh$-transformed within-group $z$-score. We provide a formal analysis showing that joint optimization of the two objectives induces gradient conflict in early training, motivating the sequential design . Experiments on five datasets demonstrate consistent improvements in both accuracy and response conciseness across model backbones. Our code is available at https://github.com/XrkArul/err_response

Learning from agile software development

Self-organized Learning in Software Factory: Experiences and Lessons Learned

What Can Software Startuppers Learn from the Artistic Design Flow? Experiences, Reflections and Future Avenues

Why Early-Stage Software Startups Fail: A Behavioral Framework

Software startups are newly created companies with little operating history and oriented towards producing cutting-edge products. As their time and resources are extremely scarce, and one failed project can put them out of business, startups need effective practices to face with those unique challenges. However, only few scientific studies attempt to address characteristics of failure, especially during the early-stage. With this study we aim to raise our understanding of the failure of early-stage software startup companies. This state-of-practice investigation was performed using a literature review followed by a multiple-case study approach. The results present how inconsistency between managerial strategies and execution can lead to failure by means of a behavioral framework. Despite strategies reveal the first need to understand the problem/solution fit, actual executions prioritize the development of the product to launch on the market as quickly as possible to verify product/market fit, neglecting the necessary learning process.

Software development in startup companies: A systematic mapping study

Context: Software startups are newly created companies with no operating history and fast in producing cutting-edge technologies. These companies develop software under highly uncertain conditions, tackling fast-growing markets under severe lack of resources. Therefore, software startups present a unique combination of characteristics which pose several challenges to software development activities. Objective: This study aims to structure and analyze the literature on software development in startup companies, determining thereby the potential for technology transfer and identifying software development work practices reported by practitioners and researchers. Method: We conducted a systematic mapping study, developing a classification schema, ranking the selected primary studies according their rigor and relevance, and analyzing reported software development work practices in startups. Results: A total of 43 primary studies were identified and mapped, synthesizing the available evidence on software development in startups. Only 16 studies are entirely dedicated to software development in startups, of which 10 result in a weak contribution (advice and implications (6); lesson learned (3); tool (1)). Nineteen studies focus on managerial and organizational factors. Moreover, only 9 studies exhibit high scientific rigor and relevance. From the reviewed primary studies, 213 software engineering work practices were extracted, categorized and analyzed. Conclusion: This mapping study provides the first systematic exploration of the state-of-art on software startup research. The existing body of knowledge is limited to a few high quality studies. Furthermore, the results indicate that software engineering work practices are chosen opportunistically, adapted and configured to provide value under the constrains imposed by the startup context.

Towards Abstraction and Automation in Software Engineering

Novel software development approaches are embracing abstraction and automation techniques. It is claimed that abstraction and automation techniques increase the productivity, improve the reusability and lower the complexity of the projects. In this study we address these new frontiers of software development by investigating on one novel proposal, namely the Ball. The Ball is an information ecosystem for authorised information containing web content, digital content as well as service development and integration. It is claimed to improve the reusability, productivity and security of software development while lowering the complexity. While improving the software developer’s productivity it should produce smaller and more reasonable software systems, leading to a better reusability and a shorter learning phase for new developers. Up to now there exists no evidence to support these claims. In this study we analyse the Ball ecosystem from multiple perspectives. We compare it to related approaches in order to find its advantages and disadvantages. In order to provide empirical data we replicated a study where a mobile information system was developed using three different technologies. The results of this study show that the Ball ecosystem has the potential to improve the productivity of software development. However, it

A Simultaneous, Multidisciplinary Development and Design Journey - Reflections on Prototyping

This paper proposes a wayfaring approach for the early concept creation stage of development projects that have a very high degree of intended innovation and thus uncertainty. The method is supported by a concrete game design example involving the development of a tangible programming interface for virtual car racing games. We focus onto projects that not only have high degrees of freedom, for example in terms of reframing the problem or iterating the final project vision, but are also complex in nature. For example, these can be projects that allow for the exploration and exploitation of unknown unknowns and serendipity findings. Process wise we are primarily focusing onto the early stage that precedes the requirement fixation, which we see as more dynamic and evolutionary in nature. The core conceptual elements that we have derived from the development experiences are: simultaneous prototyping in multiple disciplines (such as computer science, electronics and mechanics and engineering in general, abductive learning based on the outcome of rapid cycles of designing, building and testing prototypes (probing), and the importance of includingall the involved disciplines (knowledge domains) from the beginning of the project on.

What leads developers towards the choice of a JavaScript framework?

Context: The increasing popularity of JavaScript (JS) has lead to a variety of frameworks that aim to help developers to address programming tasks. However, the number of JS Frameworks (JSF) has risen rapidly to thousands and more. It is difficult for practitioners to identify the frameworks that best fit to their needs and to develop new frameworks that fit such needs. Existing research has focused in proposing software metrics for the frameworks, which do not carry a high value to practitioners. While benchmarks, technical reports, and experts' opinions are available, they suffer the same issue that they do not carry much value. In particular, there is a lack of knowledge regarding the processes and reasons that drive developers towards the choice. Objective: This paper explores the human aspects of software development behind the decision-making process that leads to a choice of a JSF. Method: We conducted a qualitative interpretive study, following the grounded theory data analysis methodology. We interviewed 18 participants who are decision makers in their companies or entrepreneurs, or are able to motivate the JSF decision-making process. Results: We offer a model of factors that are desirable to be found in a JSF and a representation of the decision makers involved in the frameworks selection. The factors are usability (attractiveness, learnability, understandability), cost, efficiency (performance, size), and functionality (automatisation, extensibility, flexibility, isolation, modularity, suitability, updated). These factors are evaluated by a combination of four possible decision makers, which are customer, developer, team, and team leader. Conclusion: Our model contributes to the body of knowledge related to the decision-making process when selecting a JSF. As a practical implication, we believe that our model is useful for (1) Web developers and (2) JSF developers.

Time for AI (Ethics) Maturity Model Is Now

There appears to be a common agreement that ethical concerns are of high importance when it comes to systems equipped with some sort of Artificial Intelligence (AI). Demands for ethical AI are declared from all directions. As a response, in recent years, public bodies, governments, and universities have rushed in to provide a set of principles to be considered when AI based systems are designed and used. We have learned, however, that high-level principles do not turn easily into actionable advice for practitioners. Hence, also companies are publishing their own ethical guidelines to guide their AI development. This paper argues that AI software is still software and needs to be approached from the software development perspective. The software engineering paradigm has introduced maturity model thinking, which provides a roadmap for companies to improve their performance from the selected viewpoints known as the key capabilities. We want to voice out a call for action for the development of a maturity model for AI software. We wish to discuss whether the focus should be on AI ethics or, more broadly, the quality of an AI system, called a maturity model for the development of AI systems.