On the Frontiers of Software Science and Software Engineering

Advances in software engineering, software science, computational intelligence, and intelligent mathematics have led to the establishment of Frontiers in Computer Science—Software (FCSS). FCSS aims to promote transdisciplinary research on software science and engineering (SSE), autonomous systems, and computational intelligence. FCSS covers not only classical empirical software engineering and industrial processes, but also contemporary topics of software science, intelligent programming languages, autonomous code generation, mathematical foundations of software, and programming knowledge bases. FCSS reports empirical studies and emerging topics in software engineering including tools, development platforms, industrial processes, management infrastructures, quality assurance schemes, big data systems, and software migrations across languages and platforms.

Software science studies the formal properties and mathematical models of software, general methodologies for rigorous and efficient software development, and coherent theories underpinning software behaviors and software engineering practices (Wang, 2014). The discipline of software science encompasses theories and methodologies, intelligent mathematics, system software, fundamental algorithms, organizational theories, cognitive complexity of software, and intelligent behavior generation theories. Recent developments in software science have paved the way to enable novel technologies for AI programming (AIP) (Wang and Xu, 2019).
Software engineering is a discipline underpinned by software science that adopts engineering approaches to develop large-scale software towards high productivity, low cost, trustworthy quality, and controllable development schedule (Wang, 2007a). Software engineering is one of the most complicated branches of engineering fields because its objects are highly abstract and intangible. It encompasses system modeling, architecting, development methodologies, programming technologies, and supporting platforms. It also covers heuristic principles, tools/environments, best practices, case studies, experiments, trials, and performance benchmarking.
This editorial addresses the objectives, missions, challenges, and latest development of Frontiers in Computer Science-Software (FCSS). In the framework of FCSS, software science foci on foundations and theoretical software engineering, whilst software engineering covers heuristic principles, tools, development environments, best practices, and programming technologies. A set of key challenges and opportunities of software science and engineering has been recognized in Challenges and Opportunities in Software Science and Engineering. The emerging fields of software science and novel technologies of software engineering are elaborated in The Frontier of Software Science and The Frontier of Software Engineering, respectively.

CHALLENGES AND OPPORTUNITIES IN SOFTWARE SCIENCE AND ENGINEERING
Despite the fast growth of software engineering over the past 60 years, software development has still required intensive manual interactions in the software industry (Dijkstra, 1976;Hoare, 1978;Wang, 2014). This phenomenon indicates a fundamental challenge to both theories and technologies of Software Science and Engineering (SSE), which are substantially constrained by the following reasons and traditional practices.
1) The fundamental theories towards software science are immature: It is indicated by a common perception shared by many researchers and practitioners that software engineering does not obey any known physical laws. However, there is a lack of basic research seeking what really are the laws and their theoretical foundation underpinning SSE. 2) The traditional perceptions on the essences of software are questionable: Software or program is used be treated as a list of code. However, latest discoveries reveal software is a cohesive system of intelligent behaviors generated by dynamic interactions between the sets of operational events (E), process models (PM), and structural models (SM) across the three dimensions (Wang, 2004;Wang, 2008a). 3) Essential Intelligent Mathematics (IM) for modeling and manipulating human and software behaviors are missing: IMs (Wang, 2020) for SSE are contemporary mathematical means beyond propositional logics and discrete mathematics, which encompass system algebra, concept algebra, and Real-Time Process Algebra (RTPA) (Wang, 2008a), etc. It is discovered that suitable IMs for software system specifications and algorithm descriptions had been left behind to the demands in SSE. As a result, none of the essential processes from user requirement elicitation, system specification, to code generation may be rigorously manipulated towards the maturity of software science. 4) The current programming languages are anti-productive because they are not designed for machine enabled software generation: Our typical programming languages are still machine-oriented constrained by deterministic condition-driven compilers. The limited expressive power of them, particularly in the most important real-time environments, has substantially constrained their adaptation to intelligent software specifications and AIP towards autonomous intelligence generation (Wang and Xu, 2019). Instead, non-programmable neural networks have become the optional solutions for SSE in most challenging real-time contexts (Wang, 2004;Wang, 2008b).
A set of Grand Challenges (GCs) to SSE have been identified in basic research (Turing, 1950;von Neumann, 1946;Dijkstra, 1976;Hoare, 1978;Hoare et al., 1987;Wang, 2014;Wang, 2007a;Wang et al., 2008;Wang et al., 2021;Wang, 2002;Wang, 2007b;Wang et al., 2009a;Wang et al., 2004;Wang, 2020;Wang, 2008c;Wang, 2012c;Wang, 2004;Wang and Xu, 2019;Wang et al., 2009b) of this field, which may be highlighted by the following fundamental queries: 1) What are the necessary and sufficient conditions for enabling run-time software intelligence in SSE? 2) Why have AI and autonomous systems been developed by data-driven neural networks rather than program-driven software engineering? 3) Does that of GC2 indicate a theoretical or technical challenge to SSE? 4) How mature are our computing platforms and programming languages for enabling autonomous software generation, mostly at run-time? 5) Is Stored-Program-Controlled (SPC) computers (Turing, 1950;von Neumann, 1946), i.e., von Neumann machines (VNM) (von Neumann, 1946), adequate enough for intelligent software design? If not, what kind of computers will be needed for the next generation of intelligent software engineering? 6) Are our programming languages sufficiently expressive for designing intelligent software? What would happen to a software system if the deterministic if-then-else structures were indeterminable at designed-time or exhausted at runtime? 7) Are our mathematical means ready for rigorously expressing software system requirements? Is our inference power adequate for expressing real-time inexhaustive, indeterministic, and uncertain behaviors in SSE? 8) How may an intelligent software system be trusted and verified when its state space is infinitive in de facto, such as those of self-driving vehicles and mission-critical robots? 9) How may a nondeterministic intelligent programming language be created in order to enable run-time intelligent behavior generation for handling indeterministic events and autonomous decision-making requirements? 10) How will SSE enable the next generation of intelligent system software and autonomous behavior generation systems?
These GCs provide a set of theoretical and technological challenges to and opportunities for SSE as well as the software industry. Any breakthrough on the set of GCs will lead to a wide range of technical innovations and applications in the software and computational intelligence industries.

THE FRONTIER OF SOFTWARE SCIENCE
It is recognized that a rigorous theoretical framework of software science is yet to be sought based on a plenty of repositories of empirical knowledge about the nature of software and its development. As Edsger Dijkstra stated that "Software engineering is programming when you can't (achieve) (Dijkstra, 1976)." Therefore, software science is what one cannot solve by empirical software engineering (Wang, 2014). The pinnacle of software science is the theories of formal methods (Turing, 1950;Hoare, 1978;Hoare et al., 1987;Wang et al., 2008) and platforms of system software including operating systems, compilers, database systems, and Internet-based distributed systems (von Neumann, 1946;Dijkstra, 1976;Wang, 2014). C.A.R. Hoare has revealed that software is a mathematical entity (Hoare, 1978) that may be formally denoted by a behavioral process known as the unified process theory in formal methods towards software engineering (Hoare et al., 1987). A set of 30+ laws of programming has been discovered by Hoare and his colleagues (Hoare et al., 1987). While being a visiting professor in Prof. Hoare's laboratory at the University of Oxford, the author of this article has developed a Real-Time Process Algebra (RTPA) (Wang, 2008a). RTPA extends Hoare's sequential process theory to a system of intelligent mathematics for formally denotating system and human cognitive, inference, and behavioral processes as a general theory towards software science (Wang, 2014). Based on RTPA, a comprehensive set of 95 mathematical laws and associated theorems on software structures, behaviors, and processes has been formally established .
Software science is a discipline that studies the formal properties and mathematical models of software, general methodologies for rigorous and efficient software development, and coherent theories and laws underpinning software behaviors as well as software engineering practices. The architecture of software science encompasses theories and methodologies, intelligent mathematics, intelligent system software, and software engineering processes (Wang, 2007a). It is noteworthy that the focuses of software science are on the fundamental platforms of Intelligent System Software (ISS) including those of intelligent operating systems, intelligent requirement specifiers, intelligent compilers, and intelligent programming knowledge bases. The development of ISS will be based on an indispensable foundation known as intelligent mathematics that enables software engineering to be matured towards software science based on rigorous denotational mathematics beyond inexpressive programming languages.
It is noteworthy that IM (Wang, 2012a;Wang, 2012d;Wang, 2020) is centric in software science as a category of denotational mathematical structures. IM deals with complex mathematical entities beyond pure numbers such as abstract objects, complex relations, behavioral interactions, denotational concepts, knowledge, processes, programmable intelligence, and general systems. IM is an indispensable foundation for dealing with the abstract and complex entities of software structures and behaviors. A set of IMs have been created in the last decade embodied by system algebra (Wang, 2008b), concept algebra (Wang, 2006;Wang, 2010), RTPA (Wang, 2008a), semantic algebra (Wang, 2010;Wang, 2013), and inference algebra (Wang, 2012b) towards AIP. IM provides a coherent set of contemporary mathematical means and explicit expressive power for manipulating both complex mathematical objects and long-chains of serial or deep-layers of embedded mathematical operations in applied domains. In software science, a General Mathematical Model of Software (GMMS) (Wang, 2014) is discovered based on RTPA that reveals any software system is a derived instance of GMMS for rigorously manipulating arbitrary software systems as behavioral interactions in the universe of discourse of software (Ω) determined by the Cartesian product Ω E x PM x SM (Wang, 2014). Therefore, the maturity of IM may indicate the maturity of software science for rigorously processing system architectures and behaviors with abstract concepts, complex relations, and dynamic processes (Wang, 2020).

THE FRONTIER OF SOFTWARE ENGINEERING
The latest advances of theories and methodologies in software science, computational intelligence, and IMs have paved a way to enable machines to generate programs in software engineering (Wang, 2007a). The challenges to intelligent program generation have been constrained by the lack of autonomous programming theories and the difficulties stemmed from the complexity of software. The missing of machine-understandable semantical rules of software behaviors has prevented software engineering from advancing to intelligent program generation. Pilot studies indicate that a fusion of the analytic (mathematical rule-based) and gray-box (machine-learning-based) methodologies will be necessarily adopted towards autonomous program generation (Wang, 2004;Wang and Xu, 2019).
An ultimate strategy for the next generation of software engineering is AIP (Wang, 2004;Wang et al., 2009b;Wang and Xu, 2019), which has been enabled by a comprehensive set of software laws for software architectures, structures, and behaviors. In the AIP approach to software engineering, IMs service as rigorous mathematical means for conveying human programming knowledge and skills to machines (Wang, 2014). IMs for AIP is underpinned by: 1) System algebra for software architectural design; 2) Concept algebra and semantic algebra for rigorous requirement modeling; and 3) RTPA for formally manipulating software structures and behaviors. Not only the architectures of computational intelligent systems, but also their dynamic behaviors can be rigorously and systematically manipulated by IMs. Several large-scale projects designed based IMs have demonstrated that they are a set of powerful mathematical means for dealing with concepts, knowledge, behavioral processes, and human/machine intelligence in realworld software engineering.
The relationship between software science and software engineering is explained by analogizing those of pure and applied physics. Without theoretical physics there would be no maturity of applied physics; so is software science for software engineering. It is recognized that the phenomena where almost all the fundamental problems that could not be solved in the past 60 years in software engineering has been stemmed from the lack of rigorous theories in the discipline of software science toward autonomous software generation.

CONCLUSION
The emerging field of Software Science and Engineering (SSE) investigates into the theoretical foundations and intelligent mathematics for autonomous software generation. This editorial has explored the latest basic research in software science. Applications of software science and intelligent mathematics in software engineering and autonomous software generation have been presented. A set of key challenges and opportunities for SSE has been formally reviewed and analyzed towards intelligent software engineering and AIP. The advanced of SSE will enable the horse being put in the front of the cart in order to enhance traditional human-centered programming by intelligent machines in the central processes of software engineering.
Fronters in Computer Science (FCS)-Software (FCSS) is a new section in Journal of FCS. FCSS aims to promote transdisciplinary research and engineering applications in software science, software engineering, software architecture, and industrial processes. The coverage of FCSS encompasses not only classical empirical software engineering, but also contemporary topics of software science, AI programming, and their mathematical and cognitive foundations. Original papers, revised conference articles, and industrial technical reports are welcome in all fields and topics of software, programming, algorithms, software engineering, and software science.

AUTHOR CONTRIBUTIONS
The author confirms being the sole contributor of this work and has approved it for publication.