The sensemaking approach presented in this work is based on the user interface design idea B&P introduced in the strand of the EU project Learning Layers1 . It has been developed and validated with healthcare professionals in several co-design sessions (e.g., via participatory observation, interviews, paper prototyping) and is particularly designed for sensemaking of one’s own learning experiences (tomberg2013 ). However, since the design is primarily made for working with people’s everyday affairs, it relies upon several implicit assumptions on sensemaking. This section tries to make these assumptions explicit by applying the qualities of sensemaking distilled in chapter ?? and elaborating a framework for sensemaking around the design idea.
The user interface design idea is oriented towards the usual screen size of desktop computers. The screen area is split into two equally sized parts, the “browsing” and the “organizing” canvas, which are arranged vertically. The upper canvas is reserved for widgets which enable users to browse their digital artifacts along contextual cues (eg. time, location, topics) whereas the lower canvas gives space to widgets for organizing these items semantically. Since each canvas can only display one widget at once the user can switch widgets horizontally. Widgets shall be able to visualize entities, ie. learning “bits”, in their own way and provide interaction upon them. It shall be possible to drag bits in the upper canvas and drop them in the lower one. Furthermore, entities need to be kept synchronized across widgets so that a change made to a bit in one widget is also reflected in the others (fig. 1.1.1). Finally, not visible in the wireframes, the state of the user’s sensemaking is persisted in the background automatically without the need to save it explicitly.
The design does not confine the set of available widgets but comes with some initial suggestions. So as for the browsing canvas there could be a timeline, a geographical map and a browsable and filterable list, whereas for the organizing canvas a Venn-diagram, a layered structure, a conceptual matrix and a network graph are envisioned (fig. 1.2).
Finally, BnP should be capable of managing several “episodes” of sensemaking. An episode in the sense of BnP is sensemaking related to a specific topic, idea or question. Technically speaking, it is a means of giving a sensemaking session a name. An episode can have several versions, each reflecting the state of sensemaking (ie. the arrangement of entities and the configuration of widgets) at a certain point in time. The user can switch between episodes and between versions of episodes instantly.
Stressing again the example from the beginning one might use the B&P user interface in the following way: First, collected data is loaded into the application via Web services and visualized by the current browsing widget, eg. the timeline, which would display the bits chronologically by the creation timestamp. However, the timeline might be unsuitable if the user already knows the label of a needed bit. Instead, by switching the upper canvas to the browsable list, which displays bits in alphabetical order, finding a bit by name would be much easier.
Next, the user might find this bit related to another one which comes across while browsing the list further. In order to make this relation explicit the two bits are dragged and dropped to the lower canvas where the Venn diagram widget is active. The user can arrange the two bits spatially and draw a circle around them. The circle gets the label of the common category. Having found this representation, the user can continue the search for more bits which would fit into the same category.
However, if no more bits can be found, two things can be done: Either the representation needs to be changed (either by relabelling the circle or drawing new ones) or another widgets needs to be put in place, eg. the network graph. In that case there would already be three nodes visualized: the two bits and the category entity which was represented as a circle in the former Venn diagram widget. The edges would be drawn between the category entity and each bit - representing a “contains”-relationship. More bits can be dropped into the lower canvas and connected to the graph.
So having various widgets available can help in finding bits and building structure (representations) around them, ie. the B&P design idea seems to support the sensemaking process. In order to prove this theoretical assumption the next section reviews the design in the light of the qualities of sensemaking.
The qualities of sensemaking have been derived as a theoretical requirements for sensemaking applications in chapter ??. As they have been used in chapter ?? for evaluation of the related work B&P also needs to undergo the review of its design in the light of the qualities. This section will show that B&P fulfills these theoretical requirements.
First, the split screen design feature where the upper part is reserved for browsing and the lower part is reserved for organizing widgets apparently reflects the bipolarity of sensemaking. In the beginning, the process is more focussed on foraging for bits in the upper canvas, whereas towards the end of sensemaking, it is mostly concerned with organizing them in the lower canvas. In between the process is continuously progressing its focus, ie. the user will more and more shift his attention from browsing to organizing. Since both poles are equally important for the process, splitting the screen into two equally sized parts is a feasible way of designing bipolarity.
Second, the division into two canvases also accounts for reciprocity of sensemaking. The organize canvas can be used to build up representations based on the data in the browse canvas whereas the browsing can be guided by representations present in the organize canvas. It is this reciprocity which drives the overall sensemaking process between the two poles of foraging and organizing. So bipolarity and reciprocity complete each other in the B&P design idea.
Third, as B&P envisions various widgets for various sensemaking situations and the ease of switching between them, it adheres to the quality of context-sensitivity. Whether a tool for sensemaking is appropriate mainly depends on the context, eg. the kind of data, the specific goal, the user’s personal preferences, and so on. Furthermore, as the bits represent informal learning experiences they can not be defined by a certain type or structure. On the one hand they may vary in their intrinsic properties (textual notes, photos, audio records, etc.), on the other hand in their extrinsic ones (creation time, location, relation to other items etc.). By having the contents of both canvases to be switchable over an extensible set of widgets dynamically and independently the user can find the appropriate ones to visualize and interact with the data at hand.
Fourth, according to sensemaking’s enactivity, the design idea enables users to interact with each visible element. Generally, items can be dragged and dropped from the upper to the lower canvas. Furthermore, the design suggests a couple of specific widgets for each canvas each being interactive respectively. On the one hand, for instance, the timeline widget for the upper canvas can be panned and zoomed, on the other hand the lower canvas may contain an organizing widget for drawing rings and arranging items like in a Venn diagram.
Fifth, due to sensemaking’s quality of continuity users may cease sensemaking as soon as they see their task-specific goal achieved (Russell1993 ) or may come back later. B&P achieves that by persisting the sensemaking state continuously in the background.
Sixth, reification is also reflected in the B&P design idea as illustrated in the user scenario. When switching widgets, representations built in the one widget might serve as entities (ie. data) in another. For instance, categories may not only function as means of structuring bits but may be related to each other on a higher level of abstraction. B&P achieves that by merely enabling reification of representations instead of defining a higher ordering structure explicitly.
Finally, the individuality of sensemaking is covered a priori as informal learning experiences are personal per se. Furthermore, B&P allows for building of own representations through widgets and even the individual extension of the set of widgets.
The following list sums up the mapping of B&P design features to qualities of sensemaking:
As B&P is targeted towards a generic framework there are only a few functional requirements to mention. Most sensemaking functionality comes from individual widgets which is out of scope of the framework. However, as for design features which are related to the visualization, interaction and continuous preservation it is necessary to list at least the following:
The non-functional requirements are of more interest for the generic framework implementation because frameworks usually provide the means (the frame) to develop functionality rather than functionality as such. In the case of B&P it is a framework for sensemaking widgets which has to meet the following non-functional requirements. These also match widely with ReactiveManifesto which states four properties reactive systems comply to: responsive, resilient, elastic and message-driven.
The implementation of the prototype is split into two parts. On account of the generic requirements described above a framework for use case agnostic features was developed. The framework is intended to ease the implementation of application specific widgets which can leverage the modularity, responsiveness and serializability provided. The main part of this section is concerned with the framework implementation. As an application two widgets of the Bits and Pieces design idea have been developed on top of this framework.
The framework relies on the runtime environment of Web browsers. The decision to use the Web browser as the application platform has several reasons. First, as the Bits and Pieces framework aims to facilitate sensemaking on the Web, the Web browser itself renders the runtime enviroment for this purpose. Second, HTML52 together with CSS33 provides a feature rich framework for structuring, integrating and presenting multimedia content. As a W3C Web standard it is implemented across various Web browsers. Third, Web applications running natively in the Web browser relieve users from awkward installation requirements. Furthermore as Web browsers are pre-installed on nowadays operating systems users can start working with the Web application right away.
JavaScript is the programming language commonly used for Web application programming. On top of the browser’s runtime environment, it deals with the aforementioned requirements out of the box. As for the common interface for inter-module communication, the events API of the Document Object Model (DOM)4 can be used to trigger and listen for application wide events which allow to transmit data objects between modules. The same mechanism enables interactivity as user initiated events (eg. a mouse click) can be captured and processed further. Asynchronous outbound communication is provided by the ”Asynchronous JavaScript and XML (Ajax)”5 technique. The DOM tree, ie. the hierarchical HTML5 structure of the user interface elements, offers fine-grained access to the presentation layer as visual elements can be addressed and updated directly. Most importantly JavaScript is a dynamic scripting language which needs no compilation of its source code. Hence objects can be extended by additional properties at runtime which is especially handy in the given case of unstructured data.
However, these are low-level features of the language which are delicate to use in a productive environment. For instance, the manipulation of the DOM tree, the handling of events and the invocation of Ajax calls requires a considerable amount of code for relatively simple tasks. Due to slight differences in the various browser implementations specific knowledge and additional switches in the algorithms are necessary. Moreover, for JavaScript objects there is no communication channel like the DOM events and understandably the language does not ship with a graph database. For these reasons, a couple of open-source JavaScript frameworks have been used to ease the prototype development.
Backbone6 consists of three classes which are relevant for the prototype. Web developers can extend Backbone.Model which bundles logic for creation, access, alteration and deletion of objects. Backbone.Collection is needed for logic at the level of collections of models, for instance retrieval, addition and removal of objects. Collection contain Models in an 1:n relationship. Models can be bound to a Backbone.View, which cares for the presentation in HTML5. A view also keeps a reference to the DOM element where it puts model data to. All classes implement the Observer Pattern7 , which allows for event-driven communication between Backbone modules. For instance, a view can listen to changes to a model and trigger the appropriate functions to redraw the associated DOM element. A collection also fires events in the case of any operations invoked on it, eg. when adding a new object. Additionally Backbone.Model provides a generic API for synchronizing data with external RESTful server applications. Backbone does not impose any specific architecture but allows for implementation of a clean software structure.
JQuery8 provides a high-level API on top of JavaScript to simplify the traversal of the DOM tree, the retrieval of specific DOM elements and thus their manipulation. It also reduces the amount of code for the binding and unbinding of event listeners to the DOM which is needed for inter-widget communication. Sending AJAX calls and receiving responses is also covered by the library by providing an exhaustive callback registration interface. Furthermore JQuery’s modular structure allows for extending its functionality via plugins, eg. to get common user interface concepts like dialog boxes and drag and drop interactivity working with little effort.
VIE9 is the so-called semantic interaction framework which brings together Backbone and the Semantic Web (Grunwald2012 ) and enables developers to build interactive Web applications on top of semantic data. As the re-implementation of a graph database in JavaScript would neither be feasible nor high-performing VIE offers a subject-centric view of the semantic data based on JSON-LD (see 1.2.2). On top of Backbone it mimics a graph database by implementing VIE.Entity , which is a type of Backbone.Model, and VIE.Collection which is a type of Backbone.Collectionfor storing all entities in a central place. Every property of an entity is a URI and any entity can be retrieved from the collection by its identifying URI. Additionally, VIE provides utility functions for handling namespaces and the type hierarchy of its entities. For instance, an entity can be retrieved either by a URI or a (Safe) Compact URI (CURIE10 ). Moreover, given a type hierarchy VIE can localize an entity’s type URI within that hierarchy. The type system can be parsed and imported from JSON files which use the same format11 as Schema.org12 . The library also supports interaction with RDFa-annotated HTML content. Synchronization with various external data Web services is enabled through service adapters. Adapters for Open Calais13 or Apache Stanbol14 (Westenthaler2012 ) are already shipped with the official distribution of VIE.
Apart from the aforementioned JavaScript libraries which are inherent parts of the prototype, some additional libraries are used for utility purposes. RequireJS15 simplifies dependency management of the software modules and libraries and allows for Lazy Loading16 , a design pattern for loading JavaScript files just in time when they are needed by the application. Js-Logger17 is used for logging and debugging needs. Finally, Twitter Bootstrap18 complements JQuery in UI design issues.
The prototype leverages two essential standards from the sphere of Linked Data for the representation of semantic data based on Web technologies: JSON-LD and RDFa. Recently, both specifications have been released as official recommendations by the W3 Consortium (W3C).
The VIE framework allows for flawless integration with external semantic Web services through JSON-LD19 , a W3C standard20 for the serialization of Linked Data (Lanthaler2013 ). Building upon the JavaScript Object Notation (JSON) it introduces additional concepts in order to map JSON objects keys to URIs. For instance, the @context contains namespace mappings and general type definitions. Additional keywords like @id, @type or @list implement node identifiers, data type relations and ordered lists.
RDFa21 , also a W3C standard22 , allows for annotation of XML with RDF. It enables Web developers to markup contents of the document with semantics primarily to make the contents more machine-readable. For instance, contact information on a Web page could be directly imported to the contact list of the visitor. RDFa defines a set of attributes which denote the relation between the documents elements and semantic entities. For instance, the property attribute describes the URI (absolute or relative to the namespace) of the predicate between a subject and the contained data.
Listings 1.4 and 1.5 give examples of both represenations and the triples expressed in Turle23 notation.
There exist alternative environments for building semantically enabled applications, most of them running in the Java Runtime Environment (JRE). The following provides an overview of pros and cons of such approaches:
The Play Framework24 is a Java and Scala framework for building reactive Web applications. Together with the Imperium plugin25 it can be extended to process RDF data. The framework adheres to the MVC architectural pattern allowing for templating HTML markup in views, processing user input in controllers and representing the application logic in models. It merely runs on the server-side while enabling the addition of client-side JavaScript code as assets. Play is scalable in terms of workload and component development. It comes with a RESTful interface and WebSockets by default and allows for big data support.
Play is a good candidate for building Web applications which do not need much processing power on the client side. Its velocity stems from an asynchronous communication model and from the fact that it runs as a compiled Java/Scala application on servers. Client merely serve as thin-clients in the classical sense. However, for the implementation of interactive and rich internet applications one needs to fallback to JavaScript snippets shipped as assets. Since most of the BnP design idea is client-side oriented one would need to re-implement a whole architecture for this relying merely on such assets while the powerful server-side features of the Play framework remain unused.
ROLE (Responsive Open Learning Environments)26 implements the concept of Mash-Up Personal Learning Environments on top of a semantic model, ie. the ROLE ontology. The semantic model relies on the concept of spaces. Users can create spaces, where they can manage learning content and collaborate with other users. A space can host a bundle of Web widgets, has a list of participants in the space and enables them to communicate and collaborate. Moreover, for supporting complex applications, the widgets can exchange information across browsers by using the inter-widget communication mechanisms developed within ROLE. Messages are composed of URI/value pairs and hence allow for handling semantic data. The widget framework is oriented to work on the client-side with the server functioning as a central point of the widget store, the identity provider and the cross-browser XMPP communication.
In this respect, ROLE is a full-featured widget framework written in Java and JavaScript facilitating individual development of widgets, inter-widget communication and user collaboration. Integration and flawless invocation of widgets from the widget store is one of its main targets. However, its design is fixed to the notion of Personal Learning Environments, ie. widgets serve as small information processing and user interaction units but cannot be used for more ambitious application needs like the highly interactive and multimedial canvases envisioned by the BnP design idea. Additionally, there is no common data base for the widgets as every widget is an island of its own data. The only means of matching data is through the exhaustive communication mechanism which would be cumbersome to apply, for instance, to the Learning Loop Complex in sensemaking.
Callimachus, a wiki-based data management framework, is specifically made for Semantic Web applications. It comes with inherent RESTful APIs, user account management, various authentication mechanisms and most notably with a full-featured user interface which makes building a semantically enabled hyperlinked Web applications a matter of a few clicks. Users with minimal knowledge on Semantic Technologies can stick together an ontology with the integrated editor and create “Create”-, “Edit”- and “View”-templates for RDF classes. Templates are marked up with RDFa with support for variables (ie. parts of the template which need to adapt to changes in the RDF data model), expressions and loops. “View”-templates can be invoked and displayed on the result set of a SPARQL query. Additionally Callimachus supports a set of charts for visualizing the semantic data of an application as well as XProc27 as a W3C standardized technology for realizing Extract-Transform-Load-pipelines28 .
Callimachus implements a full stack of Semantic Web technologies, including a graph database, RDF/XML RESTful APIs, a SPARQL endpoint, an ontology editor and RDFa templates. These enable users to easily build Semantic Web applications in a “wiki”, ie. fast, way. However, Callimachus itself is more an application than a framework. In order to add new kinds of visualization or to implement highly interactive applications, one would need to go beyond the scope of Callimachus. For instance, charts are merely oriented at presenting semantic data in a visually appealing form. There is no API for programming further means of user interaction on top of visualizations. The provided JavaScript API only allows for invoking functionality which is reachable via Callimachus’ user menu anyway. Even if it were manageable to implement individual visualizations one would still hassle with setting up a way of communication between them. For instance, interactive features as required by BnP functionally, like dragging and dropping of bits between widgets, could not be implemented easily with Callimachus.
The user interaction workflow is driven by two phases. In the first phase the user collects data, ie. informal learning experiences, which might be textual notes, pictures, Web links and other types of multimedial content, with the help of mobile applications in the field. These collection services can be connected to other remote Web services which provide semantic access to the data for the second phase. Here the user operates the B&P user interface to make sense of the collection of learning bits. The data undergo a transformation pipeline through the layered architecture of the B&P framework: the Service, the Data and finally the Presentation layer.
Widgets of the Presentation Layer implement individual visualization and interaction functionality. Bits are displayed uniformly across widgets in order to ease recognition and to ensure consistent appearance when dragging and dropping bits from the upper to the lower widget. A sidebar to the right of the screen pops up on clicking on a bit. The sidebar contains detail information and allows for changing various properties of the bit (eg. the title). Double-clicking a bit opens another Web browser tab in order to dereference its URI if possible.
The B&P framework separates the concerns for remote services, data and presentation in a three-layered architecture. The service layer wraps remote Web services and prepares external data sets. The data layer curates the collection of entities of the application. It keeps references between entities consistent to adaptable data integrity constraints and bundles data loading and creation logic. The presentation layer consists of one or more views which build up the user interface from the entities given, leveraging Backbone’s declarative event handling mechanism.
In general, the service layer implements VIE’s service adapter interface VIE.Able which provides extensions for loading, saving and analyzing content. All extensions implement JQuery’s Deferred Object29 , a design pattern resembling the Builder Pattern30 for configuring the service call with parameters and callback functions. Callbacks are executed as soon as a service call, which is made asynchronously via AJAX, gets a response from the remote server. Services need to be registered with the runtime instance of VIE. Listing 1.8 gives an example.
The VIE framework provides the data layer with utility functionality for dealing with semantic data. As all entities are of the type VIE.Entity and kept in a single VIE.Collection (see fig. 1.2.5) they are subject to VIE’s semantic interaction framework. The data layer is organized in modules each handling an aspect of the application data. Modules may trigger data operation on each other to the extend of their inter-dependency. For instance, application specific data modules for a hierarchical data model can listen to certain entities being added to the entity collection (see lst. 1.10) and trigger the loading of its child entities (see 1.11). Data modules need to be initialized in the data layer’s core component AppData which can also be used to initialize additional application specific data, eg. the initial widgets to get the user start working with. Apart from this component and the data modules the data layer consists of the Data Integrity Module (Data) which subsumes common integrity functionality and CopyMachine for cloning of entities. The framework also comes with a couple of predefined data modules which are a requirement of BnP: UserData manages user data and related episodes. EpisodeData and VersionData deal with the respective data types and control for cloning of sensemaking states, ie. the arrangement of entities and widget configuration. EntityData is a special data module for common data logic of entities such as for tagging or authorship. However, appropriate application-specific service calls have to be integrated to have these modules synchronizing with external Web services.
Data modules may inherit from the Data Integrity Module in order to impose integrity constraints on their data structure. For instance, having an entity with a relationship to another type of entity may be reflected by the integrity constraint <relation1, type, relation2>. Whenever an entity is created or updated the data integrity module should check that the entity has a property named relation1 with the reference to another entity of type typeand vice-versa with relation2. If the constraint is violated it will be fixed. If the entity is deleted, respective relationships of other entities to the deleted one need to be removed also.
For these two purposes, setting up an integrity constraint and checking it upon an entity, data modules inherit two methods from Data Integrity Module:
The framework extends VIE.Entity so that it overwrites Backbone.Model’s sync method, which is used by Backbone to create/read/update/delete (CRUD) an entity to external data services. It can be used to implement generic synchronization functionality which applies to all types of entities. However, data modules might overwrite sync once more with data type specific synchronization functionality (see lst. 1.12).
The data layer synchronizes application data with the presentation layer which needs to serve immediate response to the user despite time-consuming asynchronous operations of the service layer. For instance, in the case of loading entities the data layer may provide the presentation layer with preliminary mockup data until the requested entities are passed in through the service layer. In the case of the creation of an entity the data layer may create a representation of it which exists merely on the client-side by giving it a blank node31 URI of the form _:bN with N being a serial number. The user may continue working with the temporary entity representation. As soon as the service layer hands back the response of the server-side creation of the entity containing its real URI the data layer can transmit any further changes made meanwhile on the client-side representation. See fig. 1.2.5 for a timing diagram of this data flow.
A view in the presentation layer has to keep track of changes of entities which it is projecting to the visual HTML5 frontend of the user interface. Alternatively a view may also listen to new entities added to the entity collection and create new instances of subordinate views. Individual widgets can implement meaningful visualization techniques and interaction affordances on top of the semantics of a bit. The interface of the DOM tree provides fine-granular access to respective DOM elements for either manipulating its contents or listening for user events triggered upon it. According to Backbone a view also handles user input and hence takes the role of a controller to some extend. For instance, it is feasible to have a main view which controls the instantiation of other views.
The presentation layer consists of the AppView which manages the space for the two canvases as well as application-wide events. Essentially it triggers re-rendering of widgets if the user switches versions since each version might have different widgets activated. Each version will get its representation in the DOM tree but only the current version element with its child widget elements is shown by toggling the CSS visibility property. Additionally, there are two other types of views which application specific view implementations need to reuse: WidgetView and EntityView. WidgetView functions as a facade32 between the AppView and application specific widgets. It distinguishes between “browsing” and “organizing” widgets and applies respective functionality. For instance, organizing widgets need to handle dropped entities appropriately by the help of the JQuery UI plugin Droppable33 . For each widget available WidgetView has to provide a method to create it.
On the other hand, EntityView provides common UI functionality of entities and can be overwritten by type specific views. It provides an appropriate image of an entity given a list of type-to-icon mappings and handles mouse events triggered upon its containing DOM element. Browser-generated click events are wrapped into the framework-specific “bnp:clickEntity” event which contains a direct reference to entity object. Furthermore, using the JQuery UI plugin Draggable34 EntityView makes the DOM element draggable. In order to identify the entity object which belongs to the dragged DOM element, the view also adds RDFa to its HTML markup (see fig. 1.14 and also 1.31).
Finally, EpisodeManagerView together with EpisodeView manages episodes and versions. In the header above the upper canvas the label of the current episode is displayed. A dropdown box enables the user to switch between episodes and versions. According to the MVC pattern, views are updated on changes in the model. Therefore switching first changes the property Voc.currentVersion of the user entity which then triggers re-rendering of the canvases by AppView (see fig. 1.2.5).
Apart from the layers there exist a few operative components which stick the system parts together.
Finally there exist a couple of components which have mere supportive function for the system.
BnP comes with a couple of suggestions for widgets. Two of them, the timeline and the Venn diagram, have been implemented with the framework described in the previous section. The timeline is rendered in the upper canvas and displays entities chronologically according to their creation timestamp. The Venn diagram is a widget for the lower canvas and allows for drawing circles and arranging entities spatially. Fig. 1.3 shows the mockup drawings of the two widgets together with its realization as the BnP user interface. Fig. 1.18 shows an example workflow using it.
Since the application is under heavy development by the time writing this thesis the interface has progressed and now contains additional functionality like for searching, sharing and collaboration which is all wrapped up in the sidebar component of the user interface. However, due to that functionality going beyond the scope of this thesis, it is not covered here in detail, although it is worth mentioning that the Bits and Pieces framework is still in use and allows for application specific extensions with richer features than those of the first prototype version presented here. Implementation of widget switching has also been postponed because it would not yield much relevance for the essential functionality of the framework although it would be an important feature for sensemaking as such.
Two views have been added to the presentation layer, TimelineView and OrganizeView, together with sub-views wrapping visualized entities. As for the data layer, respective data modules have been implemented, ie. TimelineData and OrganizeData, also with associated data modules for contained entities. Finally, a service adapter for the Web services of the Social Semantic Server has also found its way into the application.
In the service layer, the prototype application wraps remote RESTful Web services of the Social Semantic Server35 (SSS, Kowald2013 ), which hosts the so-called Artifact-Actor-Network (AAN, reinhardt2009 ). In AANs, users and digital artifacts can be interlinked and used together with common features of social networks. Low Level Services support sharing and subscribing processes of artifacts, provide functionalities to annotate entities with metadata, to authenticate users and to deal with digital artifacts such as texts or multimedia documents (e.g. pictures and videos) involved in the AAN. High Level Services use given semantic structures formed by Low Level Services. They exploit explicit and implicit (social) relations to provide functions that support a personalized reflection of AANs, to discuss about digital artifacts, to handle collaborative work on digital artifacts and to allow for (re-) structuring of hierarchical and ordered collections of digital artifacts (fig. 1.3.1). The SSS can also mediate data from 3rd-party collection services, eg. Evernote. As for the application SSS backs up all data storage and retrieval needs of BnP since it is also part of the Learning Layers Project and developed in parallel with BnP.
The SSS is written in Java and is accessible via REST or WebSockets. To increase interoperability, services receiving application input or delivering results to the requesting application use JSON to encode and transmit data. For the framework, REST and WebSocket JavaScript libraries are available to be included in applications directly to minimize efforts of tying the framework to custom applications.
The service adapter for BnP consists of SocialSemanticServer and SocialSemanticServiceModel. The first implements the VIE.Able interface and bundles logic for handling server request. The latter describes a subset of SSS services in terms of parameter and result types as well as pre- and postprocessing functions in a concise form. SocialSemanticService looks up service descriptions, invokes preprocessing functions on the parameters, transmits the service call to the SSS endpoint and postprocesses the result. A common preprocessing function is scrubParams which makes sure that parameters are of the type (eg. array, scalar number) expected by the service. A common postprocessing function is fixForVIE since by the time developing BnP SSS is not serving JSON-LD yet and according transformation of the result data is necessary. The application utilizes the following SSS services (excerpt from SSConns.js of SSSClientSide36 ):
Prior to the initialization of the application its type hierarchy is loaded into VIE using its loadSchemaOrg utility method. Schema.org37 is an initiative of several major search engines to standardize semantic markup for Web pages which can be parsed by their crawlers. There exist schemata for domains of events, organizations, persons, actions and many more. The whole ontology can be loaded as RDF/Turtle, RDF/XML, RDF/NTriples, CSV or JSON38 . As VIE comes with a parser for the latter the application-specific type hierarchy has been created in the same format. Fig. 1.20 provides an example definition.
There exist types for OrganizingWidget, a widget with “organizing features”, Organize, the Venn diagram widget, a generic entity type which is the parent type of, for instance, evernoteResource or evernoteNote and a userEvent type with a large body of subtypes.
TimelineData manages data affairs concerning the timeline widget, ie. of entities of the type Voc.Timeline which contain the current visible range of the timeline in terms of start and end timestamps as well as a reference to the user entity the timeline belongs to. Finally, a timeline entity has a reference to a version since widgets belong to a version in general. Hence, TimelineData, by extending the Data Integrity Module Data, imposes the following two constraints:
setIntegrityCheck(Voc.belongsToVersion,Voc.Version,Voc.hasWidget)
setIntegrityCheck(Voc.belongsToUser,Voc.User)
TimelineData does not manage the entities displayed in the timeline itself. Instead this is delegated to UserData since the user events belong to user entities. In general, the data module uses its version entity to invoke the two SSS services learnEpVersionGetTimelineState and learnEpVersionSetTimelineState. Finally, the data module provides an interface for copying its data structure in order to enable CopyMachine to clone a timeline entity. In sum TimelineData consists of the following methods:
UserData has been extended to provide user events and associated entities. fetchRange calls the SSS service uEsGet for retrieval of user event entities between given start and end timestamps. These entities have a Voc.hasResource reference to a resource entity. For a bulk retrieval of their properties, fetchRange passes their URIs on to the SSS service entityDescsGet.
Fig. 1.3.3 provides an overview of the whole data model of the application.
OrganizeData bundles data logic for entities of type Voc.Organize. As TimelineData the data module sets up the integrity constraint that Voc.Organize entities must have the relationship Voc.belongsToVersion to an entity of type Voc.Version and a relationship Voc.hasWidget vice-versa. OrganizeData also implements a copy method for cloning of an organize entity’s data structure. Finally, the data module handles the creation of orga-entities and circles and adds them to the entities collection (see lst. 1.22). An orga-entity is a wrapper around the actual resource entity which gets visualized on the canvas. In addition to the referenced resource entity, an orga-entity carries the coordinates for positioning within the canvas space.
Actual create/update/delete operations on orga-entities and circles are delegated to the data modules OrgaEntityData and CircleData. Both listen for entities of the respective type being added to the entities collection and overwrite their sync method with appropriate SSS service invocations (see lst. 1.23).
The timeline provides a time-based visualization of entities and allows for interactive configuration of its displayed time range by zooming and panning. If more than one entity overlap in the timeline they are clustered in order to clean up the browsing space. The number of entities contained is rendered as the label of the cluster. Hence, depending on the zoom level of the timeline it can provide a quick overview of the distribution of the entities by letting them be clustered accordingly. Clicking on a cluster expands the box to yield all contained entities in sequential order. Additionally the browsing widget can be zoomed automatically to show all entities of a cluster.
Sketched in the mockup but not realized in the implementation is the possibility to view entities of various users at once. This feature might be added in a later stage of the prototype. Instead just the entities of the currently logged in user are visualized. The timeline is read-only, ie. the position of entities cannot be changed. The following list sums up the functional requirements:
There exist several external JavaScript libraries for timeline visualizations. In order to assess the right one for the aforementioned requirements, several open source candidates have been evaluated to their modularity and adaptability primarily. Modularity means how reusable parts of the code are without big changes. This includes that the library shall integrate well. Adaptability means how easily the code can be extended/changed to fit own needs. This includes setting own callbacks for user interaction and changing the appearance.
Propublica Time-setter39 provides a bar with ticks for single events, coloured by group. Events can be hidden/displayed by respective group selection. There are two separate buttons for zooming in and zooming out in steps (not smoothly). Double-click on timeline zooms in too. On click on a tick the associated html is displayed below the timeline. Furthermore, there are two buttons other buttons for iterating over the events in chronological order (see fig. 1.3.5).
As for modularity, the timeline integrates view components which could be reused. Utility functions which calculate intervals and bounds of the bar for various scales could be reused also. Appearance fully customizable by CSS. Data can be ingested in JSON format on initialization and at runtime. However, no parallel, simultaneous events or time spans are possible. Additionally, it is not customizable where and when the detail view appears. This behaviour is hard-coded. Also hard-coded is the user interaction, ie. it is not possible to add one own’s interaction hooks. Finally, ticks yield too little possibilities to visual entities appropriately.
Verite Timeline.js40 provides timelines which can be moved on mouse down and zoomed via separate buttons. Events can be visualized with thumbnails and in parallel for simultaneous ones. The library offers big support for multimedia content (eg. image and video sources).
Although the appearance can be adapted by CSS overwriting, the whole library is monolithic and highly depends on Verite’s Core JS. Data can not be added or changed at runtime. Verite Timeline.js is made for a specific use-case in mind, especially for visualization of events on news sites, which are meant to be static and need not much interaction on the level of entities.
SIMILE Timeline Widget41 consists of several bands of different scale of the timeline. On each band discrete events and time spans can be visualized. When one band is moved, the others move synchronously at the various speed relative to their scale. Detail information can be obtained by hovering the mouse over an entity, and the data can be filtered and highlighted on demand.
The appearance of the widget can be adapted via overwriting CSS classes. The programming structure of the timeline is also highly modular so that individual components can reused quite easily. Data can be loaded on initialization and at runtime dynamically. Developers claim the timeline to work also with a big load of events. However, it was not flawless to get the widget running since it is poorly documented. After all, despite its rich features - also with respect to modularity - the SIMILE Timeline widget has not been maintained since 2009 and hence yields the risk of having unfixed bugs.
Chronoline42 timelines can be moved mouse down or on click on arrow buttons left and right of the timeline. Events and time spans are rendered as coloured bars, no thumbnail-based visualization of entities is possible. The title of the event is displayed on moving the mouse of it.
Chronoline depends on the popular visualization library Raphael43 and probably provides rich possibilities of adaptation of the visual appearance of the timeline. However, the code is monolithic and hard to reuse. Furthermore, Chronoline seems to be quite a young project with little community and hence with a higher probability of containing bugs.
CHAP Links Library44 is a collection of visualization charts, also containing a timeline. It provides interactive control for movement by mouse down and for zooming by scrolling, smoothly scaling from milliseconds up to centuries. Events can be ingested as JSON data and may contain simultaneous events as well as time spans. Events can even be separated in multiple lanes. Most remarkably, the timeline also provides clustering of events as soon as their bounding boxes overlap.
The appearance is highly customizable not only via CSS but also by injecting custom DOM elements. The timeline also offers a well-documented and rich API for controlling it programmatically. Additionally it comes with an event listening system, which specific callbacks can be registered with in order to bind application functionality to user events happening on the timeline (eg. when changing the time range). Although not needed by BnP, the timeline also allows for editing of events direcly, either by moving or deleting them. For CHAP Links Timeline outweighs the other libraries in terms of adaptability, modularity and feature support, the TimelineView wraps its functionality instead of implementing a timeline on its own.
TimelineView consists of UserView and ClusterHelper, which consists of EntityView and ClusterView (see fig. 1.3.5). The view is bound to the timeline entity, which holds runtime data of the timeline such as the start/end timestamp of the current range, and to the user entity, which holds user events. UserView renders the representation of the user entity which Voc.belongsTo the timeline entity. ClusterHelper manages the transformation of entities to visible representations on the timeline, either as a EntityView, if an entity can be rendered as such, or as a ClusterView, if more than one entities are too close to each other. TimelineView consists of the following methods:
The Venn diagram widget allows for arranging entities spatially by dragging and dropping them within the canvas. Circles can be drawn around them and the label of the circle can be changed. Circles can also be dragged and dropped along with contained entities and moved within the canvas. Circles may overlap and entities may be placed inside the intersections. When moving one of such overlapping circles the other ones need to move too in order to keep the arrangement of entities within the overlapping circles. Functional requirements found here:
The view for the Venn diagram widget is called OrganizeView for the external visualization tool it is wrapping is named Organize.js. This tool provides the Venn diagram features of spatial arrangement of entities and circles and has been developed in the course of the Learning Layers Project. For its implementation, there were at least two possibilities: either using HTML5 Canvas or using SVG. Considering that with SVG, each SVG element is available within the DOM and therefore open to native event handling, and taking into account that such event handling does not exist in HTML Canvas, SVG was a natural choice.
There are several libraries available for easing the development of web applications using SVG: SVGKit45 , PERGOLA46 , Raphael47 , various JQuery SVG plugins and SVG.js48 . After analyzing these libraries, SVG.js was the chosen one, since it is flexible, provides a rich set of library functions, has a good documentation and meets the needs of the Venn diagram widget. Along with this library, some plugins were also used:
Organize.js also supports user-driven changes. Data is not merely provided by the application but also by the user who may create, move, resize and delete circles or move and delete entities from the canvas. These changes are propagated by the component through DOM events which are caught by the wrapping view and then translated to further operations on the data layer. For the translation, OrganizeView internally maps IDs of SVG elements generated by Organize.js to entities, ie. OrgaEntitys and Circles. Additionally, the visualization of OrgaEntitys is managed by OrgaEntityView, which contains an EntityView of the referenced resource entity (fig. 1.3.6). OrgaEntityView renders this EntityView internally and wraps the result in an SVG representation which is then passed on to Organize.js.
OrganizeView consists of the following methods:
There is neither an event nor a method AddEntity (initial upper-case letter) since entities can only be added via dragging and dropping an entity from the upper widget. This case it handled by WidgetView (see lst. 1.31).
Fig. 1.3.6 shows how the application components play together by example of dropping an entity to the Venn diagram widget.


JSON web token (JWT), pronounced "jot", is an open standard (RFC 7519) that defines a way for securely transmitting information between parties as a JSON object.
JSON Web Token consists of 3 parts seprated by dots:
The header typically consists of two parts: the type of the token, which is JWT, and the signing algorithm.
{
"alg": "HS256",
"typ": "JWT"
}
The second part of the token is the payload, which contains the claims that represent additional data.
{
"sub": "1234567890",
"name": "John Doe",
"iat":<PHONE_NUMBER>,
"exp":<PHONE_NUMBER>,
"admin": false
}
!Notice that this information is readable by anyone. Do not put secret information in the payload or header elements of a JWT unless it is encrypted
To create the signature part you have to take the encoded header, the encoded payload, a secret, the algorithm specified in the header, and sign that.
Finally, token should look like this:
In case you want to try creating your own JWT token you can visit jwt.io debugger.
Access token is used to get access to the resource directly. They usually have short expiration time.
Refresh token provides the opportunity to get a new access token. It is used to create new access tokens after old ones have expired, or getting access to a new resource for the first time.
Access token <=30 minutes, refresh token - up to several months.
Here's an example how to set httpOnly cookie using Express framework in Node.js.
res.cookie('refreshToken', refreshToken, { httpOnly: true });
Important to note: when refreshing access token both access and refresh tokens should be updated.
In Cookie Sessions the server is responsible for the authentication and the client does not know what happens at the server side after sending a request.
Advantages of JWT
Disadvantages of JWT


{% extends "_post.html" %}
{% hyde
title: "Friendly Find"
snip: "A friendlier find(1)."
created: 2012-11-19 19:00:01
exclude: False
%}
{% block article %}
[Friendly Find][] is the friendly file finder.
It's meant to be a more usable replacement for find(1). If you've used [ack][],
then `ffind` is to `find` as `ack` is to `grep`.
[Friendly Find]: https://github.com/sjl/friendly-find
[ack]: http://betterthangrep.com/
{% endblock %}


React Product Tour - Example 1
Test Example
← Getapper Logo
Very long text
Other piece of website to show


On this page we have two controllers which nest. The child controller
contains a directive that creates a new isolate scope. The isolate scope
maps/binds to scope properties in the child
and parent scopes.
- Get some coffee or tea. This one's complicated.
- Click the #rb#, check the "key" checkbox, then click the #psb# to see
the initial state.
The controllers and the directive each have a scope. The directive's
scope is an "isolate" scope, which means it does not prototypically inherit
from its parent scope. Rather, it prototypically inherits from a |Scope|
object. The black dashed line that emanates from the isolate scope does not
point to the parent scope like we've seen up until this point. Rather, it
points to the |Scope| object.
(Note, the |Scope| object appears even if the Peri$scope "Scope"
checkbox is unchecked, because some scope other than the |$rootScope|
inherits from it.)
As you can see from the solid blue arrow, AngularJS still maintains a
child → parent relationship between the isolate scope and its parent
scope, which is accesible via the |$parent| property on the child/isolate
scope. But don't be tempted to use this property, as it can get unwieldy
when scopes nest.
The directive also has its own controller, which is used to add property
|ctrl| to the directive |$scope|. Note how each |$scope| has a |ctrl|
primitive property that hides/shadows the parent |$scope| property of
the same name.
Isolate scope property |combo| uses interpolation to pull in values from
properties on both of its ancestor controller scopes. There is no dashed
reference line associated with this property because it does not map to a
single ancestor property. This is also why the cell is shown in a
reddish color.
Conversely, |prim1| references a single ancestor property, hence it has
a dashed line emanating from it.
Isolate properties that use @ binding will always show the
interpolated string result in the isolate scope after the @
symbol.
Isolate scope property |model2| references object property |parentModel2|
in ParentCtrl's scope, whereas
isolate scope property |myProp| references primitive property |parentModel.prop|
in ParentCtrl's scope.
Note the subtle difference in where the purple dashed lines end up:
the head of the dashed line emanating from |model2| points to the value of
|parentModel2| – the object, whereas
the head of the dashed line emanating from |myProp| points to the value of
|parentModel.prop| – i.e., primitive value model prop.
Isolate scope property |myArr| references array property |childArray|
in ChildCtrl's scope.
Isolate scope property |myFunc| uses & binding. Peri$scope currently
does not show which ancestor property is referenced by & binding
(contributions welcome, hint, hint).
- Uncheck the "key" checkbox. Type something in each textbox, then click
the #psb#.
Even though |myProp| uses ngModel with a primitive, ancsestor |$scope|
property |parentPrimitive| is affected because of the = binding.
The string values of the isolate scope properties that bind with @
are updated.
- Click the "add array element" link below, then click the #psb#.
The isolate scope push()ed a new value onto property |myArr|,
which references an ancestor property, so the ancestor was affected.
- Click the "run function" link below, then click the #psb#.
The isolate scope called myFunc(), which, due to &
binding, calls a method on ParentCtrl, which adds some text to property
|parentPrimitive|.
The isolate scope properties that bind to that property using @
are updated.
Tips: You can actually bind to primitives using =.
If you don't bind to an ancestor property, you can't access it in the
isolate scope, because it doesn't prototypically inherit from its |$parent|.
See also this
StackOverflow question about how to choose the correct type of scope to
use when creating a directive.


{% extends 'base.html' %} {%import 'bootstrap/wtf.html' as wtf%} {%block content%} {{super()}}
Don't have an account? Sign up here


--- title: Getting Started With pyiron description: ---
If you are new to the pyiron framework, please check out this video tour of its features and usage.
MyBinder hosts remote JupyterHub servers where the pyiron codebase is already installed. You can even create a new notebook from scratch on the server once it's running - just be aware that MyBinder is meant for testing, so once you close the instance your changes will be lost.
Start the pyiron MyBinder server here. The bootup can take 2-5 minutes as it installs the latest version of pyiron from the repository.
Open the first_steps.ipynb
notebook and follow the tutorial at your own pace.
Experiment with your own modifications and new code!
You can also find a number of advanced workflows and specific simulation protocols in the notebooks accompanying papers under our blog.


Qpid Proton 0.24.0 Release Notes
Proton is a high-performance, lightweight messaging library. More
about Qpid Proton.
For more information about this release, including download links and
documentation, see the release overview.
Note: This release contains a change in behaviour for SASL mechanism selection. The GSSAPI and GSS-SPNEGO SASL mechanisms are now disabled by default, and are only available for use if explicitly enabled. See this comment for more details on enabling use of the mechanisms.
New features and improvements
- PROTON-1354 - Disable GSSAPI and GSS-SPNEGO SASL mechanisms if they are not explicitly enabled
- PROTON-1683 - support static library output
- PROTON-1848 - [Python] Update to only support versions 2.6, 2.7 and 3.3 onwards
- PROTON-1850 - [Python] Split up monolithic proton __init__.py
- PROTON-1858 - [Python] Rewrite wrapped C handlers in python
- PROTON-1865 - Improve split between general SASL code and the specific implementations
- PROTON-1869 - [Python] Compiler conversion warnings with Win64 builds
Bugs fixed
- PROTON-1854 - [Python binding] Using message properties under Python 3 generates NameError 'unicode'
- PROTON-1855 - [ruby] copy link terminus state for incoming links
- PROTON-1856 - [ruby] auto-accept over-writing user transfer state
- PROTON-1857 - [cpp] no access to AMQP connection offered/desired capabilities
- PROTON-1859 - [cpp] auto-accept over-writing user transfer state
- PROTON-1860 - [cpp] connection::container_id should return the remote container-id
- PROTON-1861 - [ruby] offered/desired capabilities should be decoded as "multiple" fields
- PROTON-1863 - [cpp] need support for anonymous link targets
- PROTON-1866 - cannot tell whether peer specified expiry-policy on terminus
- PROTON-1867 - Debug libs missing in Windows build
- PROTON-1868 - [Python] pn_handle_t binding does not reliably work with Win64
Apache Qpid, Messaging built on AMQP; Copyright © 2015
The Apache Software Foundation; Licensed under
the Apache
License, Version 2.0; Apache Qpid, Qpid, Qpid Proton,
Proton, Apache, the Apache feather logo, and the Apache Qpid
project logo are trademarks of The Apache Software
Foundation; All other marks mentioned may be trademarks or
registered trademarks of their respective owners


{% extends "users/layout.html" %} {% load static %} {% block head %}
It's super simple!
First, you make your own account, which will give you your personalized suggestions.
You'll need to put in your location, but don't worry, this can be changed along with your password later! Once you are done, you will need to log in to access your account.
When you log in, you will be greeted by the dashboard with your location, weather, and temperature.
You will also see our suggested choices for the current weather. This will change to be more personalized as you add more data to it.
Whenever you access your dashboard, it will take some time to load. Don't panic! The machine is working hard to produce your results.
On the top, you will see the navigation bar. Explore the options! They will become available once you log in.
On the dashboard, you will see the options recommended to you.
To get more accurate results, think about the options and select the ones you dislike and press the button at the bottom to train the machine.
If you do not see an option that you like, you can click the 'Explore more options' button to add them.
You can either see our recommended suggestions if your selection becomes too narrow, or you can put a specific combination in yourself.
Important note: This machine is loosely trained on intervals of temperature and weather conditions and may not immediately be accurate.
To make it more accurate, please give it your input.
Also, changes may not happen immediately, it may take a couple of times for it to fully register and remember.
You may notice sometimes that the machine will recommend a wide range. This is normal when the machine is indecisive. You can make it more accurate by whittling down the options, making it more specific.


| Name | Description |
| agentOutOfDate |
Agent is out of date
Since vSphere API 4.1
|
| agentUpgrade |
Agent is being upgraded
|
| insufficientLicenses |
License not available after host upgrade
|
| licenseExpired |
License expired for the host
|
| passwordDecryptFailure |
Failed to decrypt password
Since vSphere API 4.1
|
| sslThumbprintVerifyFailed |
Failed to verify SSL thumbprint
|
| unknown |
Unknown reason
Since vSphere API 4.1
|
| userRequest |
User requested disconnect
|
| vcVRAMCapacityExceeded |
The vRAM capacity of vCenter will be exceeded
Since vSphere API 5.1
|


(.%) children chronic family caregivers variables study research n = ) caregiver families (%) Social Q-SV health life pediatric psychosocial {border-style disease patients quality sociodemographic diseases px;} time #ffffff;} expert SVs (.%, Health Sociodemographic burden care anxiety items medical social used Table disease. relationship value depression participants questionnaire study, National association characteristics conditions effects empirical . ± . Psychol factors level mean n = ), related relevant results reviewers BMC Toledano-Toledano Work age differences important literature measurement n = ). patient px; resilience {font-family ./.. ./s--- caregiver’s consequences depression, diagnosis disease, findings font-size hospitalization include included informed instruments observed participation present status studies type & < Depression Infantil Mexico Nurs Questionnaire Study Test Workers addition, answers anxiety, caregivers. context criteria double; final frequency impact judges negative number processes support useful version well-being work χ = . (M = ., (n = ) Beck Caregiver Factors Fam Family Federico Gómez Hospital However, Institute Institutes Med México Pearson’s Psychological Quality Variables associated border-color border-width correlation data df = , dimensions evaluated evaluation greater health, illness information investigate life. mothers origin psychological received significant solid; syndrome variables. voluntary {font-style {font-weight < . Anxiety Child Christian Dev Mexican Moral Pediatr Public Rev U = -. Validated Variable Work. [], accordance adversity analysis bold boys burden, cancer caregiver, cases city complex conducted consent courier; diseases. elapsed em; evaluating families. field functioning girls main married measuring mental para parenting parents participate performed positive provided pt;} review risk service sex study. test. tests two-tailed using validation Age


Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium
Our trombones use the shiniest brass which is sourced locally. This will increase the longevity of your purchase.
Our trombones use the shiniest brass which is sourced locally. This will increase the longevity of your purchase.
Our trombones use the shiniest brass which is sourced locally. This will increase the longevity of your purchase.
$600
$900
$1200


Installation¶
There are three alternatives to use the package in your own software:
- Using the package directly from Spark Packages.
- Adding it as a dependency to your project through Maven central.
- Compiling the source code and using the
jar
file.
Alternatively, if you just want to execute simple scala scripts locally, you can use the provided docker image as explained in Quick Start
Using Spark Packages¶
The easiest way of using the package is through Spark Packages, as you only need to add the package in the command line when running your application:
spark-submit --packages com.enriquegrodrigo:spark-crowd_2.11:0.2.1 application.scala
You can also open a spark-shell using:
spark-shell --packages com.enriquegrodrigo:spark-crowd_2.11:0.2.1
Adding it as a dependency¶
In addition to Spark Packages, the library is also in Maven Central, so you can add it as a dependency in your scala project. For example, in sbt you can add the dependency as shown below:
libraryDependencies += "com.enriquegrodrigo" %% "spark-crowd" % "0.2.1"
This allows you to use the methods inside your Apache Spark projects.
Compiling the source code¶
To build the package using sbt you can use the following command inside the spark-crowd folder:
sbt package
It generates a compiled jar
file that you can add to your project.


This page is a catalog of the datasets that have been tested to
work well for access with the Geo Data Portal (GDP). Select a
dataset below to see more details and access it.
The increasing availability of downscaled climate projections and
other large data products that summarize or predict climate and
land use conditions, is making use of these data more common in
research and management. Scientists and decision makers often need
to construct ensembles and compare climate hindcasts and future
projections for particular spatial areas. These tasks generally
require an investigator to procure all datasets of interest en
masse, integrate the various data formats and representations into
commonly accessible and comparable formats, and then extract the
subsets of the datasets that are actually of interest. This process
can be challenging and time intensive due to data-transfer,
-storage, and(or) -processing limits, or unfamiliarity with methods
of accessing climate and land use data. Data management for
modeling and assessing the impacts of future climate conditions
is also becoming increasingly expensive due to the size of the
datasets. The Geo Data Portal addresses these limitations, making
access to numerous climate datasets for particular areas of
interest a simple and efficient task.
{{#if isLandingPage }}
Most users should select a dataset from this page. Click the following button for advanced users:
{{/if}}
{{#if aoiMessageContext.sciencebase}}
{{/if}}
{{#if aoiMessageContext.defaultCaller}}
Areas of interest {{aoiMessageContext.defaultCaller.itemId}} from {{aoiMessageContext.defaultCaller.caller}} already selected.
{{/if}}


I am a Sophomore here at Point Park and I also play baseball.
I'm Majoring in Information Technology since I have always been interested in how computers work and learning code.
| Databases |
| Networking and Security |
| Intro to Programming |
| Business Analytics |
| Data Structures |
| Web development |
| Cyber Security |
| Operating Systems |
| Mobile App Development |


404
Oops. This page has gone missing.
You may have mistyped the address or the page may have moved.
Back to Home
Dark Mode


- NAROTO
- TOM & JERRY
- ONE PIECE
- HUNTERX
- DEATH-NOTE
- ROBEN-HOD
- ADNAN & LINA
- MAROCO
- HAIDEY
- PINKY & BRAIN
- I'm a civil engineer graduated from Yarmouk university.
- I worked as a site engineer in many schools in a lot of places in Jordan.
- I'm a student at Abdulaziz Alghurair scholarship for programming.


Hello, My name is Jamir Holmes, currently a student attending Ranken Technical College in Wentzville.
I have lived in Missouri all of my life. I was raised in Hazelwood until the age of seven, when my family then moved to Saint Peters. From then I've moved around St. Charles County many times. During my childhood and early adolescense, I had a known affinity towards computers. My like of technology was basic, but it was still difficult to find me doing anything else besides using the family computer. Another hobby of mine has always been art. I don't consider myself to be much of a creative anymore. In high school, I was not deadset on any particular career path
Duis tempus sagittis leo. Morbi eleifend eget enim non semper. Etiam at ultrices risus, eget tincidunt lacus. Aliquam nec sem nunc. Etiam mattis interdum tortor eget commodo. Pellentesque at nibh vel eros venenatis pretium. Quisque elementum lorem non risus lobortis, non tincidunt ligula posuere. Maecenas quam nulla, euismod elementum aliquam nec, tempor at dolor. Proin vitae tincidunt lacus. Praesent tincidunt in mauris suscipit venenatis. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.


Mercenary Redfoot:
Shall we open the box? This lock should be no problem for me... There we go... That was too easy. Now, what do we have here?
What's this, Dire Wolf Pelts? They appear to have been tanned by a leather craftman, but not very well. They could possibly be used to make hats. You should be able to sell these at the market.
Return


--- creation_epoch:<PHONE_NUMBER> lastmod_epoch:<PHONE_NUMBER> categories: ['Tech Tricks'] title: Installing Ubuntu 8 from usb key --- I needed to install Ubuntu on a laptop without a CDROM drive. I followed the guide on https://help.ubuntu.com/community/Installation/FromUSBStick for directions to install via a USB drive.
I copied all the files to the usb key and made it bootable as per instructions on the web, but the installer doesn't seem to work. I can boot from the USB key and get a live session working, but installing to hard disk just doesn't seem to work.
I keep getting the following error: [Errno 5] Input/output error
My guess is that it cannot find some file on the usb key or something. If I figure it out I'll post an update here.
My setup:
Update
I looked into the system's log and noticed a bunch of these errors:
[ 254.136906] SQUASHFS error: sb_bread failed reading block 0x73aef
[ 254.136910] SQUASHFS error: Unable to read page, block 1ceb2f80, size 8e6c
[ 254.136958] SQUASHFS error: zlib_inflate returned unexpected result 0xfffffffd, srclength 131072, avail_in 126, avail_out 131072
Most people report that is due to a faulty iso or cd, but I am using a usb key drive and have downloaded the iso multiple times with no change. Others have suggested possible faulty memory on the machine, so I'm going to test that next.
Resolved!
Turns out I have a usb key drive that is damaged. Even though I ran chkdsk and also used HDTune disk scan it still didn't work. I ran Linux's badblocks to find the defective sectors.
Either way I used a different usb key drive, and it worked just fine.


About tabs.js
tabs.js is a JavaScript class that will help you turn a regular set of anchor links into tabs.
Advantages
- tabs.js manipulates URL fragments, so that bookmarking or sharing a link will preserve the opened tabs (can be turned off if undesired)
- tabs.js has very little markup requirements and does not set any CSS rules, just classes and attributes
- tabs.js encourages markup that will still work perfectly for users without JavaScript
Features
tabs.js is rather small (~3KB minified), supports multiple tab sets as well as nested tabs and can be configured to suit most needs.
Markup requirements
- Have some links that target your tabs (using hashtags and IDs)
- Make sure those links are within an element that has the
data-tabs
attribute - Make sure the actual tab content elements have the correct IDs set (to match the links)
Usage
For every tabset on your page, create a new Tabs()
instance, then call init()
on it. If you don't need to refer to the instance later on, this can be done very compact: (new Tabs()).init();
Styling your tabs
It depends a bit on how you structure your markup. Check the CSS code used in this very page for some pointers in the right direction.


Comma separated list of hosts.
Please provide the full host name, not part of the host name.
Do not enter the fully qualified domain name


# Welcome!
_Start typing to dismiss this_
Webdown is a web based markdown editor. It uses marked to parse markdown. You can type _any_
markdown **and** it shall be parsed
Welcome!
Start typing to dismiss this
Webdown is a web based markdown editor. It uses marked to parse markdown. You can type any
markdown and it shall be parsed


Welcome
Woodpecker is a team of professional in the wood processing
and the creation of wooden furniture of the highest class. We
are a family of artisans and designers who believe that to make
things well, you must put your heart in it. Unique, quality wood
products you will keep forever. We are glad to have you around!
Our tema takes over everything,form an idea and concept
development to realizatoin. We belive in traditoins and
incorporate them within our innovations. All our projects
incorporate a unique artistic image and functional soluctions.
Clients is the soul fo the projects. Our main goal is to illustrate
his/hers values and individuality through design. Our clients are
daring and successful people, businessmen and celebrities,IT
compaines and large banks, media companies and creative
agencies, store and restaurant chains, international developing>
compaines, educational centers and public institutions. All our
clients have one prevalling trait-they are bold and modren, they
like to stay ahead of trends, and work with the best.
Subscribe to our email list or follow for updates
hello@woodpecker.com


CONFIDENTIAL
Access to the Chromium Committers list is restricted to committers only. {% if login_url %} Log in. {% endif %}
Please follow one of the links below to access the list you want.


A post
This is an example of using shorthand to build a blog post.
Parts
-
build.shorthand - this is the shorthand file orchestrating everything
-
post.md - the Post we want to make in Markdown
-
template.md - is a markdown file with shorthand embedded, it is our template because we embedded shorthand
-
template.html - an HTML rendering of the template to show HTML but un-resolved shorthand still in it.
-
post.html - the final post
Process
Run the build process
shorthand build.shorthand
This reads in build.shorthand which intern pulls in template.md to use as a template with content taken from post.md rendering the final post.html.


Venice is flooded right now and it looks miserable
by Mark FrauenfelderRising tides and rain in Venice are flooding the city, and hotels are giving guests knee-high rubber boots so they can slosh their way from one tourist attraction to another.
From Yahoo News:
The high water, known locally as “acqua alta”, was amusing for tourists and a nuisance for residents going about their business, but levels were far lower than the 1.94 meters (6ft 4in) in the devastating November 1966 flood.
But even lower levels of the salty high water over the years take their toll on the city, eroding foundations of homes, businesses and city buildings.
Bad weather is continuing to dog Italy, with no real let-up forecast for several days.
Image: YouTube


- Players will earn and accumulate points throughout the year by playing in certain events that
have been designated as Season Long Points events and are listed below.
- For all individual events, points will be awarded to players based on their individual score.
For all 2 person team events, points will be awarded to players based on the team score with
each player receiving equal points. For all 3 person or more team events, players will be awarded
points based on their own individual score, not the team score. Each player on the team may receive
different points depending on their own score and regardless of how their team does.
- In the event of ties in each specific event, there will be no tie breakers. The applicable
points will be distributed amongst the tied participants.
- At the end of the year, the Top 20 players in points in both the Gross and Net categories will
receive pro shop credit prize money based on their position and also qualify for the Jim Law
Memorial Shootout.
- In each specific event, players will earn both Gross and Net points, however for the end of the
year payouts those players that finish in the Top 20 in both Gross and Net categories will only
be paid out in whichever category they finish higher in. In the event a player finishes in the same
position in the top 20 in both the Gross and Net categories (i.e. 8th place gross and 8th place
net) the default will be to pay them in the gross category.
| Place |
Wednesday Night |
Weekend Majors |
Club Championship |
|
Wednes. |
Majors |
Champ. |
| 1 |
30 |
60 |
75 |
| 2 |
25 |
50 |
60 |
| 3 |
20 |
40 |
45 |
| 4 |
18 |
36 |
38 |
| 5 |
17 |
34 |
36 |
| 6 |
16 |
32 |
34 |
| 7 |
15 |
30 |
32 |
| 8 |
14 |
28 |
30 |
| 9 |
13 |
26 |
28 |
| 10 |
12 |
24 |
26 |
| 11 |
11 |
22 |
24 |
| 12 |
10 |
20 |
22 |
| 13 |
9 |
18 |
20 |
| 14 |
8 |
16 |
18 |
| 15 |
7 |
14 |
16 |
| 16 |
6 |
12 |
14 |
| 17 |
5 |
10 |
12 |
| 18 |
4 |
8 |
10 |
| 19 |
3 |
6 |
8 |
| 20 |
2 |
4 |
6 |
| others |
1 |
2 |
4 |


1. Identity Finds accounts on the device. 2. Location Knows your precise location. 3. Photos / Media / Files Reads the contents of your USB storage. Modifies or deletes the contents of your USB storage. 4. Camera / Microphone Takes pictures and videos.

1. You must be over 13 years old. 2. can change these terms any time they want without telling you. 3. You can’t be a convicted criminal. 4. can use your content in any way they like. 5. You can close your account at any time ( can as well). 6. is not responsible If you DIE or are INJURED by using the service. Anything you do on your account (In case you break the law). Any third party content. 7. Legal No guarantee the service will be error free (Viruses / Wrong information / Stops working). You must not copy or modify any copyrighted material (Name / Logo). Claims have to be settled through arbitration. All claims must be within 1 year. You can only sue on your own (Not as a group). If you break the law while using the service, don’t involve . 1. Don’t bully anyone. 2. Don’t request money or commit fraud. 3. Don’t send spam. 4. Don’t use someone else’s pictures without permission. 5. Don’t use the service for illegal activities. 6. Don’t attack the service or servers. 1. If you close your account, will still keep certain information. What Information They Collect Name Email address Address Telephone number Your messages Facebook information Location Language How They Use The Information Targeted ads Customize the services Improve their products Customer support Analysis (Number of users) Who They Share It With Other users Service providers (Businesses that offer a service to Amazon eg. Legal / Customer Support) Advertising companies Other third parties Government agency If another company buys or merges with


--- title: Hello World! author: Roni Rosenfeld and Ryan Tibshirani date: 2020-08-10 tags: - COVIDcast authors: - roni - ryan heroImage: blog-lg-img_hello-world.jpg heroImageThumb: blog-thumb-img_hello-world.jpg summary: | Hello from the Delphi research group at Carnegie Mellon University! We're a group of faculty, students, and staff, based primarily out of CMU together with strong collaborators from other universities and industry. Our group was founded in 2012 to advance the theory and practice of epidemic forecasting. Since March 2020, we have refocused efforts towards helping combat the COVID-19 pandemic, by supporting informed decision-making at federal, state, and local levels of government and in the healthcare sector. Until now, we've been pretty “heads down” with our work, and slow to communicate what we've been up to. But at last ... Delphi finally has a blog! This first post serves as an introduction of sorts. Future posts will dive deeper into our various projects. output: blogdown::html_page: toc: true ---
Hello from the Delphi research group at Carnegie Mellon University! We’re a group of faculty, students, and staff, based primarily out of CMU together with strong collaborators from other universities and industry. Our group was founded in 2012 to advance the theory and practice of epidemic forecasting. Since March 2020, we have refocused efforts towards helping combat the COVID-19 pandemic, by supporting informed decision-making at federal, state, and local levels of government and in the healthcare sector. Until now, we’ve been pretty “heads down” with our work, and slow to communicate what we’ve been up to. But at last … Delphi finally has a blog! This first post serves as an introduction of sorts. Future posts will dive deeper into our various projects.
We (Roni and Ryan) are co-leads and co-founders of the Delphi group. When we started the group back in 2012, our mission was to develop the theory and practice of epidemiological forecasting, with a long-term vision of seeing this technology become as universally accepted and useful as weather forecasting is today. In the following years, we developed both nowcasting and forecasting models, focusing primarily on seasonal influenza in the US. Our forecasting system is a perennial top finisher in the Centers for Disease Control’s annual forecasting challenges. In 2019, we were named one of the CDC’s two Centers of Excellence for Influenza Forecasting.
Back when we formed the group in 2012, the “original four” members were David Farrow, Logan Brooks, Roni, and Ryan. By early 2020, pre-pandemic, we’d grown to about 7-8 members in size, and were happily and steadily making progress on flu forecasting and nowcasting, and making headway into dengue and norovirus. To learn about the work our group has done in the past, including some papers we’ve written, software tools we’ve built, and the real-time epidemiological data server we’ve been deploying since 2016, check out {{< reflink "/" "our website" >}}.
When the COVID-19 pandemic arrived, we focused all our attention on it. Our Delphi team quickly grew to 30+ members, and is still growing. Most of our members are volunteers, drawing talent from within CMU and several other universities, including Stanford, UC Davis, and USC, and also from industry. The pace has been intense and dizzying at times, and we’re infinitely grateful for the contributions and commitment of all our new members—we’d be nowhere without them. See {{< reflink "team" "here" >}} for a list of the Delphi team members.
With new members comes a new breadth of expertise: our expertise now covers statistical modeling, computation, systems engineering, user interfaces, visualization, digital epidemiology, and epidemic forecasting. We’ve been extremely fortunate to have developed several new relationships with stakeholders and supporters in government, the healthcare sector, and the tech industry; and of course, we’re proud and grateful for our existing relationships, especially our longstanding relationship with the CDC.
While Delphi’s long-term mission remains to advance the theory and practice of epidemic forecasting, since March 2020 our goals are to help combat the COVID-19 pandemic and save lives and livelihoods. We aim to support informed decision-making at federal, state, and local levels of government and in the healthcare sector. Whenever possible, we strive to make our work useful to the private and public sectors, other researchers, the press, and the general public.
Our strategy:
Improve pandemic situational awareness and understanding by providing comprehensive, geographically-detailed, and continuously-updated indicators of pandemic activity and its impact, helping to make meaning out of the pandemic information deluge.
Support local, state, and federal governments’ ongoing decision-making in their attempts to balance public health concerns with economic preservation, by providing validated, verifiable, localized, short-term forecasts of epidemic spread and healthcare demand, under any assumed level of the local population’s mobility and distancing behavior.
Analyze and demonstrate the impacts of governments’ past tightening or loosening of mitigation measures (e.g., opening or closing schools or businesses, imposing or lifting bans on gatherings, shelter in place orders, etc.) on a population’s mobility and distancing behavior.
Engage continuously with our target users to communicate our findings, and inform our directions and priorities.
Make our products useful and accessible to other researchers and tool developers, to amplify their impact. To that end, we’ll continue to make everything we invent or produce publicly and freely available as soon as possible and to the greatest degree allowed, including models, algorithms, software, tools, estimates, and forecasts.
So what have we been doing since March? We’ve been working towards our strategic goals above, and have made good progress on some of them.
Here’s a quick summary:
We’ve built a number of new indicators of COVID-19 activity. These are fine-grained geographically (most of them are available at the US county level) and temporally (all of them updated daily). They are designed to shed light on the current picture of COVID in the US, beyond the typical publicly-available metrics like confirmed cases and deaths.
Some of our indicators are based on massive-scale surveys that we’re running through partnerships with Facebook and Google, and others are based on aggregated counts from massive medical claims data sets through partners like Change Healthcare.
We’ve built a {{< apireflink "api/covidcast.html" "public API" >}}, and {{< apireflink "api/covidcast_clients.html" "R and Python packages" >}}, to serve our indicators to researchers and the public. This API provides new data daily.
We’ve built {{< reflink "covidcast" "interactive maps and graphics" >}} to display our indicators, and better inform the public and decision-makers.
We’ve developed forecasts of the future spread of the pandemic, validated them prospectively, and started submitting them to CDC.
In subsequent posts, we’ll dive deeper into many of these projects, and touch on what’s next for us (a lot… in many ways, we feel that our most important work is still ahead of us). Until next time!


Wellcome traveller!
Do you wish to punish your offender?
Or maybe you want to earn some coins
for head hunting?
Assign an award for a head
or open the list with orders
«No Payment No Headshot!»
"Sir Gyles de Murforte"


riak
Developed with solid distributed systems fundamentals from the start, Riak scales out to meet your needs. It also scales down easily, making development and prototyping easy.
Whatever size you need it to be
"Scalability" is an often-misused word on the Web. Scaling is not the same as being fast, and it is not the same as being large. To say meaningfully that something scales, you must do so in terms of some numerically measurable feature (throughput, latency, volume, anything you can describe with a single number) and some other numerically measurable resource that presumably costs you money (such as the number of computers being used). To say that something scales is to say that there is a relationship between that resource and that feature which remains constant regardless of how much you increase the numbers. This is practically useful because it gives you predictable cost ceilings when your needs grow. If there is no such useful resource/benefit relation, your system does not scale. (and if turning the dial way up on your scaling factor causes some other aspect of your system to perform much worse, your system's scalability is questionable at best)
One important way in which Riak scales is in the relationship between total storage capacity and the number of disk-containing servers in the cluster. If your cluster has a given total capacity of some number "C", and is comprised of "N" servers (which roughly equivalent amounts of disk in each) then you can double your capacity by doubling your number of servers -- no matter what the original values of C and N.
This is a huge deal, as it means that you don't have to keep packing more and more resources into a single master database, incurring greater and greater marginal expense the farther you go. Instead, when you need more capacity you just plug in another ordinary server and walk away.
Most storage systems (including both traditional RDBMS and some more recent document databases) do not scale in any meaningful way. While you can often add replicas to such systems for redundancy or load-balancing, such systems still require all of the data to fit on a single master. As soon as you run out of room to add disks to that master, you establish a maximum practical capacity.
Some systems achieve scaling through sharding, or dividing the data up into segments, each of which is owned by a separate master. This achieves some scaling, but typically at the cost of multiplying the points of failure that can bring everything crashing down. Between namenodes responsible for knowing which shard is which and the fact that each of these shards must now be treated with all of the care of the previous master, operational concerns can climb rapidly as such systems grow. The operational design of Riak does not have any of these drawbacks. Riak's scaling is done not by making more "master" locations, but by having no master at all.
Another essential and often ignored aspect of scaling is "scaling down". Systems that are designed to work in the large are often very inconvenient to set up, manage, and use in a very small environment such as a developer's laptop. If a system cannot run in a scaled-down and simple setup, it will be much harder for developers to explore the system and work with it to its fullest potential. Riak works well even when running on just a single node; developers can easily work against a local instance and have the same code work when deployed on a large cluster elsewhere.


Stay Mad
Home
(current)
About
Gallery
Progress
Apply
Group 8
Stay Mad Streams
Shoes - Tank
Rollow - Tank
Clawthorne - Warlock
Liquidblue - Shaman Healer


{% set projects = PROJECT_DATA[SERIES] %} {% extends "templates/base.tmpl" %} {% block pagetitle %}User Guides{% endblock %} {% block title %} Documentation > User Guides {% endblock %} {% block content %}
The central user guides managed by the OpenStack Documentation team were deprecated and removed during the Pike release cycle. The content was moved to the individual project documentation trees. Because of the timing of that change, the Ocata version of the user guides may be out of date. If you encounter problems, please refer either to the version of the guides created for Pike, or the most recent series in development, instead.
User Guides In Development ({{SERIES_IN_DEVELOPMENT|title}})


Can anyone give me construct a pseudocode for this program want to be able to better understand the processes and functions require to write the code. Its about a Movie Theater.
1. Login: when this activity is performed, the user enters their user-id; the program
searches the “login.bat” or “login.txt” file for that user-id. If the user-id is not found
in the login file the program informs the user that he/she is not a registered user and
then asks if he/she would like to register with the application. If the user chooses to
register with the application, initiate the Registration functionality (see functionality
2). Otherwise, if the user-id is found ask the user to enter their password and then
compare it with a copy of the password from the “login.*” file. If the credentials
match the program displays the program menu; other wise, advise the user that their
credentials are incorrect and ask the user is he/she wish to exit the program.
2. Register: when this activity is performed, the program accepts the following
customer date: full name, date of birth, age [calculated using date of birth], email
address, contact number, password, and date registered. The program should generate
a sequential user-id. Save all data (except the password) to a file called
“customer.dat”. The following data is saved to the login file (“login.dat” “login.txt”):
user-id, password, and category. The program randomly assigns a category [Worker,
Customer] to the user and informs the User of the category he/she is assigned. After
the user registers successfully offer the login screen (see functionality 1).
3. Add Movie: when this activity is performed, the program accepts the following movie
data from a Worker: movie code, title, PG rating [13, 16, MA], duration in minutes,
director of the movie, type of movie [action, comedy, romance], status [active,
inactive]. Only ACTIVE movies can be scheduled for showing. The Worker uses this
activity to add a new movie to the “movies.dat” file. This file will have data
pertaining to all movies shown/showing at the movie theatre.
4. Update Movie: when this activity is performed, the program accepts the movie code
from the Worker and changes the corresponding movie status in the “movies.dat”
file.
5. Movie Schedule: when this activity is performed the program generate a daily movie
schedule from the “movies.dat” file based on ACTIVE movies. All movies are
schedule 3 hours apart. Movies are shown from 11:00A.M. to MIDNIGHT every day.
The following data is stored in a file called “movieschedule – dd-mm-yyyy.dat”:
movie code, title, PG rating [13, 16, MA], duration in minutes, director of the movie,
type of movie [action, comedy, romance], and show time and price of movie ticket.
Only one (1) movie can be scheduled in a cinema at a time.
6. Buy Ticket: when this activity is performed the program displays a copy of the movie
schedule for that day. The Customer enters the movie code and the program searches
the “movieschedule – dd-mm-yyyy.dat” file using the movie code and displays the
movie title, duration, PG rating, show date, show time and price of the ticket. The
programs then asks the user to enter payment for the ticket if he/she is sure they want
to buy that ticket. Payment must be greater than or equal to the cost of the ticket.
Once payment is validated the program prints receipt and automatically initiates the
Generate Movie Ticket functionality.
7. Generate Movie Ticket: when this activity is initiated, ticket details such as: movie
title, date of movie, show time, PG rating, and price is displayed for the customer to
view on the screen and then added to a file called “tickets.dat”.
Notes
• On STARTUP the program should ONLY display the login screen. See
functionality 1.
• The Worker can perform all functionalities. While the Customer menu can ONLY
perform 1, 2, 6, and 7.
• The theatre can only seat 100 persons. Therefore the number of tickets sold
CANNOT exceed the number of seats in the cinema. See functionality 6.
• A customer can ONLY purchase 2 tickets at a time. See functionality 6.
Instructions
* use of modularity, randomization, arrays, repetition, structures, unions,
enumeration, and files.The user should be able to exit a screen/area of the program at
anytime.
There are several mostly independent pieces here. I'd write each one separately and test it. Then you can worry about hooking them together. For example, write the code to add a movie. Then use a small main() program to call that function. Run it an examine the movies.dat file to see if you did it right.
Some other thoughts:
I'd have the login() function return 3 possible values: successful login, registration request or unsuccessful login. The calling code can decide what to do based on that. Put another way, I would NOT have the login function call the registration code directly. One function should do one thing.
Q: if the user's password is wrong and they DON'T want to exit the program, what happens?
Q: #4: "changes the corresponding movie status" seems vague. Does this mean that that the sole function of "update" is to switch the movie status from active to inactive or vice versa? Can you edit the details of a movie?
If you can indeed edit the details of a movie then I'd have one function that edits an in-memory movie instance. The "add movie" function calls this with an empty record. "Update movie" calls it with a record read from the movies.dat.
I'd split up #6 into two bits of code. The first selects a movie, the second collects the payment.
i understand but its just to test if the used of the calling function is understand first before doing it into one function.
No the details remain the same basically the whole program can be constructed to a better working program but that the scenario i wanna solve whats given first before going onto more complex forms as you explained. so help me out with this psuedocode.
@Ndrewm
Show us your attempt at the first part then we can provide assistance/comment. If you can't get started then revise your class notes and textbook.:)
Well manage for my psuedocode so far but stuck NEED HELP BADLY!!!!!!!!!
Int Login()
START
DECLARE userId[10] , paswrd[10], cChoice AS CHARACTER
DECLARE CHANCES AS INTEGER
DECLARE userId 1[] = “ndrew”
DECLARE password1[] = “program”
PRINT “Enter USER Id Number”
INPUT userId
PRINT “Enter Your Password”
INPUT password
WHILE (chances)
PRINT“ENTER USER ID ----->”
INPUT userId
PRINT “ENTER YOUR PASSWORD---”
INPUT password
IF (strcmp(userId1, userId) == 0 AND strmp(passwrd1, password) == 0)
PRINT”Correct Username And Password”
break
Else
PRINT”INVALID USER NAME AND ID”
chances—
IF (!chances)
PRINT”YOU HAVE NO MORE CHANCES”
PRINT”DO YOU WANT TO REGISTER Y\N”)
IF (cChoice ==’y’ or cChoice == ‘y’)
PRINT”ENTER YOUE NEW ID USERNAME--”
INPUT userId1
PRINT “
Chances = 3
ENDWHILE
Void Register()
START
DECLARE custName[20], AS CHARACTER
DECALRE emailAdd, dateReg AS INTEGERS
DECLARE dob, age, birthyr, curryr = 2014 AS INTEGERS
PRINT”Enter Your Name”
INPUT custName
PRINT”Date Of birth”
INPUT dob
PRINT”ENTER YOUR BIRTH YEAR”
INPUT birthyr
PRINT”ENTER YOUR EMAIL ADDRESS”
INPUT emailAdd
PRINT”ENTER DATE REGISTERED”
INPUT dateReg
age = curryr – birthyr
save as cutomer.dat
display Login()
save as login.dat
STOP
Int AddMovie()
START
DECLARE movieCode AS INTEGER
DECLARE char MovieTitle[20] AS CHARACTER
DECLARE PgRating[] = {13, 16, MA} AS CHARACTER
DECLARE m_dur AS FLOAT
DECLARE movieDictr[20] AS CHARACTER
DECLARE movieType[] = {action, comedy, romance} AS CHARACTER
DECLARE movieStatus[] = {active, inactive} AS CHARACTER
IF movieStatus search == movie.dat
PRINT”%s”, active”
PRINT“MOVIE AVAIBLE FOR ENTRY”
PRINT”
ELSE
IF movieStatus search <> movie.dat
PRINT”inactive”
PRINT”MOVIE NOT AVAIBLE FOR SHOWING”
Fclose(movie.dat)
STOP
- display login screen
- user inputs ID
- search login file for corresponding ID
- if no corresponding ID found on file
then inform user is not registered and ask user if user wants to register
- if user wants to register initiate registration function
otherwise display login screen
Look at my first post I did up to movie status n that's where it got complicated I jus like to get a different point if view of the pseudocodes before implementing in into c language. Reason y so fast I have till 8am to in morning to summit this pseudocode :-(
The sample I gave is, more or less, the way I was shown how to write pseudo code which is simply a translation of the given problem as a basis for detailed coding. You can see that it is substantially different to what you wrote. However it's your call where you go with it.