SISTEM INFORMASI PENJUALAN PADA KEDAI DEGAN BANG MOLOOR

Kedai Degan Bang Moloor is a shop that supplies consumption needs with or more commonly referred to as young coconut, this shop is also one of the largest suppliers of young coconut in the Purwodadi Grobogan area. The shop also provides various types of young coconut, ranging from young coconut as a natural treatment, young coconut for consumption and young coconut as a cultural tradition. Every day a lot of young coconuts are sold in this shop and the demand for young coconut every day is increasing continuously, especially when entering the holy month of Ramadan, the demand for coconut fruit consumption can increase to ten times from a normal day. In this shop, all information about transactions is done manually, starting from bookkeeping, recording accounts receivable and calculating the available stock of goods. So that we need a system that is able to process the data so that it becomes fast and efficient. For this reason, this research was conducted which aims to make it easier for the owner of the shop to get information about profits and losses, stock of goods and other financial data. This study uses the Waterfall method which consists of needs analysis, design, coding, testing and application. The development of this system uses several software, namely: PHP, Mysql, Visual Code Studio, CodeIgniter and Javascrip

Approximate Normalization for Gradual Dependent Types

Dependent types help programmers write highly reliable code. However, this reliability comes at a cost: it can be challenging to write new prototypes in (or migrate old code to) dependently-typed programming languages. Gradual typing makes static type disciplines more flexible, so an appropriate notion of gradual dependent types could fruitfully lower this cost. However, dependent types raise unique challenges for gradual typing. Dependent typechecking involves the execution of program code, but gradually-typed code can signal runtime type errors or diverge. These runtime errors threaten the soundness guarantees that make dependent types so attractive, while divergence spoils the type-driven programming experience. This paper presents GDTL, a gradual dependently-typed language that emphasizes pragmatic dependently-typed programming. GDTL fully embeds both an untyped and dependently-typed language, and allows for smooth transitions between the two. In addition to gradual types we introduce gradual terms , which allow the user to be imprecise in type indices and to omit proof terms; runtime checks ensure type safety . To account for nontermination and failure, we distinguish between compile-time normalization and run-time execution: compile-time normalization is approximate but total, while runtime execution is exact , but may fail or diverge. We prove that GDTL has decidable typechecking and satisfies all the expected properties of gradual languages. In particular, GDTL satisfies the static and dynamic gradual guarantees: reducing type precision preserves typedness, and altering type precision does not change program behavior outside of dynamic type failures. To prove these properties, we were led to establish a novel normalization gradual guarantee that captures the monotonicity of approximate normalization with respect to imprecision

Achieving Self-Sustainability in Interactive Graphical Programming Systems

Programming is fraught with accidental complexity. Software, including tools used for programming, is inflexible and hard to adapt to one's specific problem context. Programming tools do not support Notational Freedom, so programmers must waste cognitive effort expressing ideas in suboptimal notations. They must also work around problems caused by a reliance on plain text representations instead of Explicit Structure. The idea of a Self-Sustainable programming system, open to adaptation by its users, promises a way out of these accidental complexities. However, the principles underlying such a property are poorly documented, as are methods for practically achieving it in harmony with Notational Freedom and Explicit Structure. We trace the causes of this difficulty and use them to inform our construction of a prototype self-sustainable system. By carefully reflecting on the steps involved in our specific case, we provide insight into how self-sustainability can be achieved in general, and thus how a motivated programmer can escape the aforementioned sources of accidental complexity