Thank you for your interest in ScignScape and the
Online Science Resource Workshops.
ScignScape provides a combination of software/code tools and research resources combining perspectives of cognitive science, cognitive humanities, and philosophy of science. These perspectives are explored at different levels, from research articles to code libraries: concepts explored in theory can be utilized in code, and vice-versa. ScignScape offers software libraries for static analysis, code generation, data modeling, and Semantic Web integration, principally to support Semantic Web-compatible database solutions; secondarily for such goals as document preparation, language processing and “Natural Language Database” design, data visualization, and 3D programming. These are areas which can enrich our understanding of cognitive/computational/humanities integration, and correlatively data/language/application integration. Conversely, software can promote research embracing collaborative, networked visions of academic and general community scholarship, like annotated papers which join in to the Semantic Web and related information-sharing practices, such as sharing and serializing documents in multiple formats and for multiple end-media. And overarching both of these goals is the complex relationship between more and less formal models of language, logic, cognition, and computation — how formal theories can shed light on more enactive, encultured, phenomenological cognitive/semiotic/social practices, and vice-versa.
A central premise of ScignScape is the impossibility of exact separation between formal and informal semantics (or logic/cognition/language...). The “informal” can be an emergent property or higher-level synthesis of the “formal”: real-world human language, reasoning, and sign-systems exhibit many different formal system, which because of their superposition and interaction do not appear to mechanically determine cognition, but which have formal properties that can be studied in isolation. Individual theories of meaning or grammar, or cognitive models or processes, may distort cognition by stripping cognition from its proper context — but this may be a useful idealization, like studying a single cell or molecule. “Isolated” cognitive models can be formalized into systems precise enough to be computationally modeled, and help technology incorporate the rich but semi-structured realms of natural language and epistemic collaboration. Considering the importance of “information” to modern society and economy, building technology which can work with the information embedded in semi-structured domains, like natural language, is a major priority.
This vision of “semi-structured” data is commonplace in the research (and commercial aspirations) of the current tech world. But it also leaves unstated many assumptions and working paradigms: about the feasibility of algorithms which progressively distill formal structures from semi-structured repositories to the point where data aggregates with well-understood computational properties emerge; about global statistical patterns in language and data which can point beyond surface ambiguities and “noise”; about the tendency of patterns to emerge in data progressively expanded within and culled from largely unregulated environments. These assumptions need to be articulated and examined, and challenged or defended on philosophical foundations. The tools presented here generally make the assumption that such regularity and emergence reveals the coherence of cognitive models and processes through which we “create” data — observations we make and categories or structures we realize become the data with enough conscious or linguistic salience to be available for perpetuity, for example in our language acts or our use of software. The vision of “extracting” data from human speech and action therefore rests on an implicit vision of structural correspondence between cognitive data spaces; between factors which drive the morphology of cognition (factors like spatial and part-whole relations, categorizations, networks of concept-relations) and the technical systems which drive the technological aggregation and curation of data (database technology, Category Theory, Denotational Semantics, Process Algebras, Object-Oriented Data Models, and so forth).
This idea of formal-to-cognitive structural correspondance, and of real-life cognition being a non-mechanical but emergent synthesis of formal constituent cognitive phenomena, has influenced a system of tools which will be discussed and in some cases presented here. These tools are mostly organized around the goal of managing and integrating Semantic Web data, including using Semantic Web compatible data models as a central feature of application data and how this data can be properly identified and routed between computer code, databases, applications, natural language, and effective interactive use of software (so people can manage information in visual, intuitive ways). Software developers and Software Development Engineering — the field of designing software development tools, such as computer languages and IDEs (Integrated Development Environments) — can honor cognitive/computational/humanities research while maintaining their central focus on practical application building. Database backends which deal extensively with language and semantics — including Natural Language and the Semantic Web — confront the slippery line between formal and informal meaning. Structures must migrate from language and human conceptualization into computational models that can be represented in a database, conveyed in code, and used by software, often where they are given an interactive visual form in which they “reenter” the world of human meaning and practice, giving rise to new data and repeating the cycle. Between end-users and computations is a spiral of semiotic mappings between formal and informal semantics and logic. To enable and analyze this process, the “formal” and “informal” must be interconnected; the academic line which places informal semantics (say) on the side of “humanities” and formal semantics (Modal Logic, Category Theory, Formal Concept Analysis, Lambda Calculus) on the side of “science”, “mathematics”, “theoretical computer science”, must be erased.
Certain trends in Software Development Engineering merit special attention for this formal-to-semiformal cycle the Semantic Web, but also the problem of mapping Semantic Web to Application data (expanding on the notion of “Object Relation Mapping”, or migrating between applications and relational databases). Object Orientation, itself, has evolved toward models synergetic with both formal semantics and real-world conceptualization. The Functional and Object-Orientated paradigms are increasingly blurred, weather by Object-Orientated languages embracing functional conventions (like newer versions of C++ embracing lambda blocks and passing lambdas between functions), or by functional languages supporting complex object models (like the Common Lisp Object System). An emergent Object-Functional Semantics, if we consider real-life features present or promised in widely used programming languages, deserves closer attention — studying the similarities and differences between semantics afforded by C++14, Perl6, Ruby, Haskell, OCaML, Lisp, etc. These cross-languages studies have not been fully carried out, partly perhaps because important new versions of some languages are not yet fully implemented (like Perl6 and C++ Concepts, which will perhaps specified as of C++17). There is a lively interchange of ideas between languages, particularly as language implementers try to marry the mathematical elegance and formal precision of Lisp or Haskell with the relative clarity of C++ or Java for large-scale application design. For programmers interested in formal models of real-world human language and concepts, the evolving semantics of programming languages is an important part of formal semantics generally — collectively the structures recognized by these languages are a good rough indication of the upper bounds of semantic complexity and nuance which is computationally tractable. A theory of formal implementation semantics — those semantic models which can be practically implemented for coding languages — is an important part of formal semantics overall. The overlap, between such “implementable” semantics and real-world human conceptual structures, reveals a kernel for theorizing the interplay between formal and informal logic and semantics.
Most ScignScape libraries are according concerned with linking computer code to language and concepts. This can take the form of extracting data from natural language, but also designing data models which reflect innate conceptual tendencies, and with interconnecting many such models. There are several strategies for managing the formal/informal boundary, including taking natural language (considered “informal” for sake of argument) directly as source or representation of information, or taking Semantic Web structures which are intrinsically schema-agnostic. The code developed here largely pursues a compromise “multi-specification” strategy: assume that conceptual domains can be most fairly modeled in terms of many “local” specifications, collaboratively developed with careful attention to the specific concepts exercised by specific communities who use and cultivate the relevant software, with an overarching network (perhaps consistent with the envisioned Semiotic Web) that allows similar but not isomorphic data models to inter-communicate. Applications developed in this spirit are collaboratively, carefully attuned to real-world concepts in specific domains, and based on relatively complex but targeted data models which reflect natural language “signifying practices” in their domain but still impose formal regularities. The goal is to build software architectures on a foundation of these models, defining the models themselves (influenced by both formal and informal or semi-formal semantics) and then progressively defining serialization, database layouts, live memory representations, and application management of the resulting data structures. A central premise for these architectural goals is the benefit of Semantic Web compatible data models both for interface structures and live memory: ScignScape therefore provides a “vertical” collection of libraries which deploy Semantic Web concepts within application runtimes. This inspires the idea of a Semantic Readtable — a technique for treating semantic graphs as “hosts” for runtime evaluation — which can be used for both state code analysis and dynamic runtimes; for example, as a “hook” into a Lisp readtable or as a C++ code generators. Later pages on this site will describe libraries for parsing code into such Semantic Readtables and then using it in various contexts, from runtimes to code and document generators.
Some of these technologies will be discussed and demonstrated at upcoming meetings. Please check the links above for upcoming events, or for annotated summaries of prior events, as well as readings, introductions to speakers, links, and technical details. Thanks!