intro

Introducing The Age of Paradise

Fr. John Strickland talks about the newly released book The Age of Paradise. The book is available at store.ancientfaith.com.




intro

Introduction to Part 3

Father John welcomes listeners back to the podcast with the opening to its third part, the age of utopia. He also summarizes some of the main points of his recently released book The Age of Division, which tells the history of Christendom covered in the second part of the podcast.




intro

Introducing The Age of Nihilism

Fr. John Strickland gives an overview of his latest book, The Age of Nihilism, available at Ancient Faith Store: https://store.ancientfaith.com/the-age-of-nihilism-christendom-from-the-great-war-to-the-culture-wars




intro

Introduction to Part Four of the Podcast: Friedrich Nietzsche in Bayreuth

In this introduction to the final part of Paradise and Utopia, Fr. John reads the prologue to his recently released book, The Age of Nihilism: Christendom from the Great War to the Culture Wars. The episode introduces the nihilistic philosopher Friedrich Nietzsche and the role compositions by Richard Wagner played in his formation. Included are musical excerpts of the latter's famous "Wedding March" and "Ride of the Valkyries."




intro

A Pilgrimage to Alaska - Introduction

Fr. John Parker recently traveled to Kodiak, Alaska, and Spruce Island, Alaska, for the Feast of St. Herman of Alaska. While there, he had the chance to speak with all sorts of Orthodox Christians who minister in this beautiful, holy land of America. Today he introduces this series and then we will post updates every couple of days.




intro

This Present Moment: Practicing Orthodox Spirituality in an Age of Distraction - Introduction

Dn. Michael Hyatt returns to his Sunday school class and begins teaching through Time and Despondency: Regaining the Present in Faith and Life..




intro

The Apostolic Fathers - Introduction

Dn. Michael Hyatt begins a new series on the writings of the Apostolic Fathers, those second-generation Christian writers who learned at the feet of the Apostles themselves. Dn. Michael is using The Apostolic Fathers in English by Michael W. Holmes.




intro

Thinking Orthodox - Introduction

A new church school class has started at St. Ignatius Orthodox Church in Franklin, TN taught by Dn. Michael Hyatt. Dn. Michael is teaching through the popular book by Dr. Jeannie Constantnou - Thinking Orthodox. This is the introductory lesson. If you don't have a copy, order one today. Available in print, eBook, and Audiobook formats.




intro

Introduction

Introductory show




intro

Lord's Prayer - Introduction




intro

The Beatitudes - An Introduction




intro

Introduction to Prayer

Fr. Apostolos reminds us that while prayer is difficult, it is essential to our salvation.




intro

Divine Worship: Series Introduction

Fr. Apostolos introduces a miniseries of sermons about the spiritual depths of Divine Worship and starts by explaining the word leitourgia.




intro

The Inner Person in the Orthodox Tradition - Introduction

In this introductory episode to a new series on the inner person in the Orthodox tradition, Fr. Maxym discusses the meaning of the soul and the relationship between the soul, the heart and the mind.




intro

An Introduction to God

Bobby interviews Fr. Andrew Stephen Damick, the author of the new AFP book An Introduction to God: Encountering the Divine in Orthodox Christianity.




intro

An Introduction to The Saint Constantine School

Dr. John Mark Reynolds introduces The Saint Constantine School, a new K-College Orthodox school.




intro

Introduction

Wesley introduces his podcast, as well as the concept of human exceptionalism.




intro

Introverts and Extroverts

Dr. Albert Rossi discusses the difference between introverts and extroverts.




intro

The Way: A Multimedia Resource for Introducing Orthodox Christianity

Bobby Maddex interviews David and Mangala Frost of the Institute for Orthodox Christian Studies (IOCS) about a new IOCS Orthodox evangelism tool called The Way, now available in the United States exclusively through Conciliar Press.




intro

Introducing the Ancient Faith Book Club!

Join siblings Bobby Maddex and Molly Sabourin as they glean spiritual insights from modern literature. Listen to this introduction to learn more about the book club schedule, how the podcast will operate, and the ways in which you can participate. The first book is The Power and the Glory by Graham Greene, and the discussion will take place one month from now—on October 7, 2019. Click here to purchase the book, view the whole book list, and leave a message for Molly and Bobby. Get reading!




intro

Be the Bee Intro

Be the bee. Focus on the beauty that God has put in everyone and everything. For more on the bee metaphor, see St. Basil's Address to Young Men on Greek Literature and Advice from Elder Paisios.




intro

Introduction

Annalisa in now an “official” Ancient Faith podcaster! Here she introduces her video podcast to her new audience.




intro

Health minister aims to introduce duty of candour

The law could force health staff to be open with patients and their families when mistakes are made.




intro

Education reforms to be introduced in phases

Deputy Andrea Dudley-Owen says changes to the law will be introduced in "bite-sized chunks".




intro

Restrictions introduced as Bluetongue case identified

A restriction zone has been extended to cover the island and part of Hampshire.




intro

Roblox introduces new safety features, Australia bans Under 16s from social media

Roblox is introducing new safety features for children under the age of 13, following criticism of how it protects younger users. The free online gaming platform, which has around 70 million […]

The post Roblox introduces new safety features, Australia bans Under 16s from social media appeared first on Tech Digest.




intro

Introducing TODS – a typographic and OpenType default stylesheet

Introducing TODS, an open source typography and opentype default stylesheet. One of the great things about going to conferences is the way it can spark an idea and kick start something. This project was initiated following a conversation with Roel Nieskens (of Wakamai Fondue fame) at CSS Day, where he demonstrated his Mildly Opinionated Prose Styles (MOPS).

The idea is to set sensible typographic defaults for use on prose (a column of text), making particular use of the font features provided by OpenType. The main principle is that it can be used as starting point for all projects, so doesn’t include design-specific aspects such as font choice, type scale or layout (including how you might like to set the line-length).

Within the styles is mildly opinionated best practice, which will help set suitable styles should you forget. This means you can also use the style sheet as a checklist, even if you don't want to implement it as-is.

TODS uses OpenType features extensively and variable font axes where available. It makes full use of the cascade to set sensible defaults high up, with overrides applied further down. It also contains some handy utility classes.

You can apply the TODS.css stylesheet in its entirety, as its full functionality relies on progressive enhancement within both browsers and fonts. Anything that is not supported will safely be ignored. The only possible exceptions to this are sub/superscripts and application of a grade axis in dark mode, as these are font-specific and could behave unexpectedly depending on the capability of the font.

In order to preview some of the TODS features, you can check out the preview page tods.html and toggle TODS.css on and off. (This needs more work as the text is a bit of a mish-mash of examples and instructions, and it's missing some of the utility classes and dark mode. But that’s what open source is for… feel free to fork, improve and add back into the repo.)

Walkthrough of the TODS.css stylesheet

You can download a latest version of the stylesheet from the TODS Github repo (meaning some of the code may have changed a bit).

Table of contents:

  1. Reset
  2. Web fonts
  3. Global defaults
  4. Block spacing
  5. Opentype utility classes
  6. Generic help classes
  7. Prose styling defaults
  8. Headings
  9. Superscripts and subscripts
  10. Tables and numbers
  11. Quotes
  12. Hyphenation
  13. Dark mode/inverted text

1. Reset

Based on Andy Bell’s more modern CSS reset. Only the typographic rules in his reset are used here. You might like to apply the other rules too.

html {
  -moz-text-size-adjust: none;
  -webkit-text-size-adjust: none;
  text-size-adjust: none;
}

Prevent font size inflation when rotating from portrait to landscape. The best explainer for this is by Kilian. He also explains why we still need those ugly prefixes too.

body, h1, h2, h3, h4, h5, h6, address, p, hr, pre, blockquote, ol, ul, li, dl, dt, dd, figure, figcaption, div, table, caption, form, fieldset {
  margin: 0;
}

Remove default margins in favour of better control in authored CSS.

input,
button,
textarea,
select {
  font-family: inherit;
  font-size: inherit;
}

Inherit fonts for inputs and buttons.

2. Web fonts

Use modern variable font syntax so that only supporting browsers get the variable font. Others will get generic fallbacks.

@font-face {
  font-family: 'Literata';
  src: url('/fonts/Literata-var.woff2') format('woff2') tech(variations),
       url('/fonts/Literata-var.woff2') format('woff2-variations');
  font-weight: 1 1000;
  font-stretch: 50% 200%;
  font-style: normal;
  font-display: fallback;
}

Include full possible weight range to avoid unintended synthesis of variable fonts with a weight axis. Same applies to stretch range for variable fonts with a width axis.

For main body fonts, use fallback for how the browser should behave while the webfont is loading. This gives the font an extremely small block period and a short swap period, providing the best chance for text to render.

@font-face {
  font-family: 'Literata';
  src: url('/fonts/Literata-Italic-var.woff2') format('woff2') tech(variations),
       url('/fonts/Literata-Italic-var.woff2') format('woff2-variations');
  font-weight: 1 1000;
  font-stretch: 50% 200%;
  font-style: italic;
  font-display: swap;
}

For italics use swap for an extremely small block period and an infinite swap period. This means italics can be synthesised and swapped in once loaded.

@font-face {
  font-family: 'Plex Sans';
  src: url('/fonts/Plex-Sans-var.woff2') format('woff2') tech(variations),
       url('/fonts/Plex-Sans-var.woff2') format('woff2-variations');
  font-weight: 1 1000;
  font-stretch: 50% 200%;
  font-style: normal;
  font-display: fallback;
  size-adjust:105%; /* make monospace fonts slightly bigger to match body text. Adjust to suit – you might need to make them smaller */
}

When monospace fonts are used inline with text fonts, they often need tweaking to appear balanced in terms of size. Use size-adjust to do this without affecting reported font size and associated units such as em.

3. Global defaults

Set some sensible defaults that can be used throughout the whole web page. Override these where you need to through the magic of the cascade.

body {
    line-height: 1.5;
    text-decoration-skip-ink: auto;
    font-optical-sizing: auto;
    font-variant-ligatures: common-ligatures no-discretionary-ligatures no-historical-ligatures contextual;
    font-kerning: normal;
}

Set a nice legible line height that gets inherited. The font- properties are set to default CSS and OpenType settings, however they are still worth setting specifically just in case.

button, input, label { 
  line-height: 1.1; 
}

Set shorter line heights on interactive elements. We’ll do the same for headings later on.

4. Block spacing

Reinstate block margins we removed in the reset section. We’re setting consistent spacing based on font size on primary elements within ‘flow’ contexts. The entire ‘prose’ area is a flow context, but so might other parts of the page. For more details on the ‘flow’ utility see Andy Bell’s favourite three lines of CSS.

.flow > * + * {
  margin-block-start: var(--flow-space, 1em);
}

Rule says that every direct sibling child element of .flow has margin-block-start added to it. The > combinator is added to prevent margins being added recursively.

.prose {
  --flow-space: 1.5em;
}

Set generous spacing between primary block elements (in this case it’s the same as the line height). You could also choose a value from a fluid spacing scale, if you are going down the fluid typography route (recommended, but your milage may vary). See Utopia.fyi for more details and a fluid type tool.

5. OpenType utility classes

.dlig { font-variant-ligatures: discretionary-ligatures; }
.hlig { font-variant-ligatures: historical-ligatures; }
.dlig.hlig { font-variant-ligatures: discretionary-ligatures historical-ligatures; } /* Apply both historic and discretionary */

.pnum { font-variant-numeric: proportional-nums; }
.tnum { font-variant-numeric: tabular-nums;    }
.lnum { font-variant-numeric: lining-nums; }
.onum { font-variant-numeric: oldstyle-nums; }
.zero { font-variant-numeric: slashed-zero;    }
.pnum.zero { font-variant-numeric: proportional-nums slashed-zero; } /* Apply slashed zeroes to proportional numerals */
.tnum.zero { font-variant-numeric: tabular-nums slashed-zero; }
.lnum.zero { font-variant-numeric: lining-nums slashed-zero; }
.onum.zero { font-variant-numeric: oldstyle-nums slashed-zero; }
.tnum.lnum.zero { font-variant-numeric: tabular-nums lining-nums slashed-zero; }
.frac { font-variant-numeric: diagonal-fractions; }
.afrc { font-variant-numeric: stacked-fractions; }
.ordn { font-variant-numeric: ordinal; }

.smcp { font-variant-caps: small-caps; }
.c2sc { font-variant-caps: unicase; }
.hist { font-variant-alternates: historical-forms; }

Helper utilities matching on/off Opentype layout features available through high level CSS properties.

@font-feature-values "Fancy Font Name" { /* match font-family webfont name */

    /* All features are font-specific. */
    @styleset { cursive: 1; swoopy: 7 16; }
    @character-variant { ampersand: 1; capital-q: 2; }
    @stylistic { two-story-g: 1; straight-y: 2; }
    @swash { swishy: 1; flowing: 2; wowzers: 3 }
    @ornaments { clover: 1; fleuron: 2; }
    @annotation { circled: 1; boxed: 2; }
}

Other Opentype features can have multiple glyphs, accessible via an index number defined in the font – these will be explained in documentation that came with your font. These vary between fonts, so you need to set up a new @font-font-features rule for each different font, ensuring the font name matches that of the font family. You then give each feature a custom name such as ‘swoopy’. Note that stylesets can be combined, which is why swoopy has a space-separated list of indices 7 16.

/* Stylesets */
.ss01 { font-variant-alternates: styleset(cursive); }
.ss02 { font-variant-alternates: styleset(swoopy); }

/* Character variants */
.cv01 { font-variant-alternates: character-variant(ampersand); }
.cv02 { font-variant-alternates: character-variant(capital-q); }

/* Stylistic alternates */
.salt1 { font-variant-alternates: stylistic(two-story-g); }
.salt2 { font-variant-alternates: stylistic(straight-y); }

/* Swashes */
.swsh1 { font-variant-alternates: swash(swishy); }
.swsh2 { font-variant-alternates: swash(flowing); }

/* Ornaments */
.ornm1 { font-variant-alternates: ornaments(clover); }
.ornm2 { font-variant-alternates: ornaments(fleuron); }

/* Alternative numerals */
.nalt1 { font-variant-alternates: annotation(circled); }
.nalt2 { font-variant-alternates: annotation(boxed); }

Handy utility classes showing how to access the font feature values you set up earlier using the font-variant-alternates property.

:root {
    --opentype-case: "case" off;
    --opentype-sinf: "sinf" off;
}

/* If class is applied, update custom property */
.case {
    --opentype-case: "case" on;
}

.sinf {
    --opentype-sinf: "sinf" on;
}

/* Apply current state of all custom properties, defaulting to off */
* { 
    font-feature-settings: var(--opentype-case, "case" off), var(--opentype-sinf, "sinf" off);
}

Set custom properties for OpenType features only available through low level font-feature-settings. We need this approach because font-feature-settings does not inherit in the same way as font-variant. See Roel’s write-up, including how to apply the same methodology to custom variable font axes.

6. Generic helper classes

Some utilities to help ensure best typographic practice.

.centered {
    text-align: center;
    text-wrap: balance;
}

When centring text you’ll almost always want the text to be ‘balanced’, meaning roughly the same number of characters on each line.

.uppercase {
    text-transform: uppercase;
    --opentype-case: "case" on;
}

When fully capitalising text, ensure punctuation designed to be used within caps is turned on where available, using the Opentype ‘case’ feature.

.smallcaps {
    font-variant-caps: all-small-caps;
    font-variant-numeric: oldstyle-nums;    
}

Transform both upper and lowercase letters to small caps, and use old style-numerals within runs of small caps so they match size-wise.

7. Prose styling defaults

Assign a .prose class to your running text, that is to say an entire piece of prose such as the full text of an article or blog post.

.prose {
    text-wrap: pretty;
    font-variant-numeric: oldstyle-nums proportional-nums;
    font-size-adjust: 0.507;
}

Firstly we get ourselves better widow/orphan control, aiming for blocks of text to not end with a line containing a word on its own. Also we use proportional old-style numerals in running text.

Also adjust the size of fallback fonts to match the webfont to maintain legibility with fallback fonts and reduce visible reflowing. The font-size-adjust number is the aspect ratio of the webfont, which you can calculate using this tool.

strong, b, th { 
    font-weight: bold;
    font-size-adjust: 0.514; 
}

Apply a different adjustment to elements which are typically emboldened by default, as bold weights often have a different aspect ratio – check for the different weights you may be using, including numeric semi-bolds (eg. 650). Headings are dealt with separately as the aspect ratio may be affected by optical sizing.

8. Headings

h1, h2, h3, h4 { 
    line-height: 1.1; 
    font-size-adjust: 0.514;
    font-variant-numeric: lining-nums; }

Set shorter line heights on your main headings. Set an aspect ratio for fallback fonts – check for different weights of headings. Use lining numerals in headings, especially when using Title Case.

h1 {
    font-variant-ligatures: discretionary-ligatures; 
    font-size-adjust: 0.521;
}

Turn on fancy ligatures for main headings. If the font has an optical sizing axis, you might need to adjust the aspect ratio accordingly.

h1.uppercase {
    font-variant-caps: titling-caps;
}

When setting a heading in all caps, use titling capitals which are specially designed for setting caps at larger sizes.

9. Superscripts and subscripts

Use proper super- and subscript characters. Apply to sub and sup elements as well as utility classes for when semantic sub/superscripts are not required.

@supports ( font-variant-position: sub ) {
    sub, .sub {
        vertical-align: baseline;
        font-size: 100%;
        line-height: inherit;
        font-variant-position: sub;
    }
}

@supports ( font-variant-position: super ) {
    sup, .sup {
        vertical-align: baseline;
        font-size: 100%;
        line-height: inherit;
        font-variant-position: super;
    }
}

If font-variant-position is not specified, browsers will synthesise sub/superscripts, so we need to manually turn off the synthesis. This is the only way to use a font’s proper sub/sup glyphs, however it’s only safe to use this if you know your font has glyphs for all the characters you are sub/superscripting. If the font lacks those characters (most only have sub/superscript numbers, not letters), then only Firefox (correctly) synthesises sup and sub – all other browsers will display normal characters in the regular way as we turned the synthesis off.

.chemical { 
    --opentype-sinf: "sinf" on;
}

For chemical formulae like H2O, use scientific inferiors instead of sub.

10. Tables and numbers

td, math, time[datetime*=":"] {
    font-variant-numeric: tabular-nums lining-nums slashed-zero;    
}

Make sure all numbers in tables are lining tabular numerals, adding slashed zeroes for clarity. This could usefully apply where a time is specifically marked up, as well as in mathematics.

11. Quotes

Use curly quotes and hang punctuation around blockquotes.

:lang(en) > * { quotes: '“' '”' '‘' '’' ; } /* “Generic English ‘style’” */
:lang(en-GB) > * { quotes: '‘' '’' '“' '”'; } /* ‘British “style”’ */
:lang(fr) > * { quotes: '«?0202F' '?0202F»' '“' '”'; } /* « French “style” » */

Set punctuation order for inline quotes. Quotes are language-specific, so set a lang attribute on your HTML element or send the language via a server header. Note the narrow non-breaking spaces encoded in the French example.

q::before { content: open-quote }
q::after  { content: close-quote }

Insert quotes before and after q element content.

.quoted, .quoted q {
    quotes: '“' '”' '‘' '’';
}

Punctuation order for blockquotes, using a utility class to surround with double-quotes.

.quoted p:first-of-type::before {
    content: open-quote;
}
.quoted p:last-of-type::after  {
    content: close-quote;
}

Append quotes to the first and last paragraphs in the blockquote.

.quoted p:first-of-type::before {
    margin-inline-start: -0.87ch; /* Adjust according to font */
}
.quoted p {
    hanging-punctuation: first last;
}
@supports(hanging-punctuation: first last) {
    .quoted p:first-of-type::before {
        margin-inline-start: 0;
    }
}

Hang the punctuation outside of the blockquote. Firstly manually hang punctuation with a negative margin, then remove the manual intervention and use hanging-punctuation if supported.

12. Hyphenation

Turn on hyphenation for prose. Language is required in order for the browser to use the correct hyphenation dictionary.

.prose {
    -webkit-hyphens: auto;
    -webkit-hyphenate-limit-before: 4;
    -webkit-hyphenate-limit-after: 3;
    -webkit-hyphenate-limit-lines: 2;

    hyphens: auto;
    hyphenate-limit-chars: 7 4 3;
    hyphenate-limit-lines: 2;    
    hyphenate-limit-zone: 8%;
    hyphenate-limit-last: always;
}

Include additional refinements to hyphenation. Respectively, these stop short words being hyphenated, prevent ladders of hyphens, and reduce overall hyphenation a bit. Safari uses legacy properties to achieve some of the same effects, hence the ugly prefixes and slightly different syntax.

.prose pre, .prose code, .prose var, .prose samp, .prose kbd,
.prose h1, .prose h2, .prose h3, .prose h4, .prose h5, .prose h6 {
    -webkit-hyphens: manual;
    hyphens: manual;
}

Turn hyphens off for monospace and headings.

13. Dark mode/inverted text

Reduce grade if available to prevent bloom of inverted type.

:root {
  --vf-grad: 0;
}

@media (prefers-color-scheme: dark) {
  :root {
    --vf-grad: -50;
  }
}

* {
  font-variation-settings: "GRAD" var(--vf-grad, 0);
}

Not all fonts have a grade (GRAD) axis, and the grade number is font-specific. We’re using the customer property method because font-variation-settings provides low-level control meaning each subsequent use of the property completely overrides prior use – the values are not inherited or combined, unlike with font-variant for example.

There are probably better ways of doing some of these things, and the preview page is rather lacking at the moment. Please let me know on Github, or better still fork it, edit and resubmit.

Read or add comments




intro

Introducing recommendations in Google Search Console

This post announces Search Console recommendations, a new feature that provides websites with optimization opportunities and suggests actions they can take to improve their presence on Google Search.




intro

Introduction to WSO2 Message Broker


Introduction to WSO2 Message Broker

Introduction
WSO2 Message Broker (MB) is a new Open Source project and product from WSO2 that provides messaging functionality within the WSO2 Carbon platform and to other clients in various languages. It works either standalone or in conjunction with products and components such as the WSO2 ESB and WSO2 Complex Event Processing Server.

MB is based on the Apache Qpid/Java project (http://qpid.apache.org). From Apache Qpid, MB gets core support for the AMQP protocol and JMS API. On top of that WSO2 has added support for Amazon SQS APIs and WS-Eventing support.

Understanding how the MB broker fits into Enterprise Architecture
The Message Broker provides three main capabilities into an overall Enterprise Architecture:
·               A queueing/persistent message facility
·               An event distribution (pub/sub) model
·               An intermediary where multiple systems can connect irrespective of the direction of messages.

To give some concrete examples of these benefits, here are some scenarios:
1)   In the WSO2 ESB, a common pattern is to persist the message from an incoming HTTP request into a persistent message queue, and then process onbound from there. MB can provide the persistent queue.
2)   The WSO2 ESB already has an event distribution model and eventing support, but the QPid-based broker provides higher performance as well as supporting the JMS API.
3)   For example, you may wish to send messages from outside a firewall to a server inside. You could connect an ESB or Service Host within the firewall to a Message Broker running outside the firewall (for example on Amazon EC2). This model is used by the WSO2 Cloud Services Gateway.

Where does AMQP fit?

AMQP (www.amqp.org) is an open protocol for messaging. Whilst the AMQP protocol is still under development, it has released three stable releases (0-8, 0-9-1, and 0-10), with a 1.0 due during 2011. There are a number of implementations of the AMQP standard in production, including Apache Qpid (both Java and C++ versions), RabbitMQ, OpenAMQ and others.

WSO2 has been a member of the AMQP working group for several years, and we strongly support AMQP as the way to introduce interoperability and greater openness into the messaging space.

The Qpid broker supports a variety of clients on top of the AMQP protocol. The most useful of these for Carbon is the Java JMS 1.1 API, which provides a portable API as well as the main interface with the WSO2 ESB. In addition there are C# and other APIs. WSO2 MB also extends these with WS-Eventing and Amazon SQS APIs for interoperability using HTTP, REST and SOAP.

Installing the WSO2 MB

You can download the WSO2 MB Beta from:

Once you have downloaded and unzipped, simply switch to the install directory

            cd wso2mb-1.0.0-SNAPSHOT
            binwso2server.bat  [ON WINDOWS]
            bin/wso2server.sh [ON LINUX/MACOSX]

Let’s refer to the install directory as from now on.

You should see the server startup:
[2011-03-16 14:00:12,471]  INFO {org.wso2.carbon.server.Main} -  Initializing system...
[2011-03-16 14:00:12,840]  INFO {org.wso2.carbon.server.TomcatCarbonWebappDeployer} -  Deployed Carbon webapp: StandardEngine[Tomcat].StandardHost[defaulthost].StandardContext[/]
[2011-03-16 14:00:14,147]  INFO {org.wso2.carbon.atomikos.TransactionFactory} -  Starting Atomikos Transaction Manager 3.7.0
[2011-03-16 14:00:19,952]  INFO {org.wso2.carbon.core.internal.CarbonCoreActivator} -  Starting WSO2 Carbon...
[2011-03-16 14:00:19,983]  INFO {org.wso2.carbon.core.internal.CarbonCoreActivator} -  Operating System : Mac OS X 10.6.6, x86_64
[2011-03-16 14:00:19,984]  INFO {org.wso2.carbon.core.internal.CarbonCoreActivator} -  Java Home        : /System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home
[2011-03-16 14:00:19,984]  INFO {org.wso2.carbon.core.internal.CarbonCoreActivator} -  Java Version     : 1.6.0_24
[2011-03-16 14:00:19,985]  INFO {org.wso2.carbon.core.internal.CarbonCoreActivator} -  Java VM          : Java HotSpot(TM) 64-Bit Server VM 19.1-b02-334,Apple Inc.
[2011-03-16 14:00:19,985]  INFO {org.wso2.carbon.core.internal.CarbonCoreActivator} -  Carbon Home      : /Users/paul/wso2/wso2mb-1.0.0-SNAPSHOT
[2011-03-16 14:00:19,985]  INFO {org.wso2.carbon.core.internal.CarbonCoreActivator} -  Java Temp Dir    : /Users/paul/wso2/wso2mb-1.0.0-SNAPSHOT/tmp
[2011-03-16 14:00:19,986]  INFO {org.wso2.carbon.core.internal.CarbonCoreActivator} -  User             : paul, en-US, Europe/London
2011-03-16 14:00:12,471]  INFO {org.wso2.carbon.server.Main} -  Initializing system...

some logs deleted

[2011-03-16 14:00:41,691]  INFO {org.wso2.carbon.core.transports.http.HttpsTransportListener} -  HTTPS port       : 9443
[2011-03-16 14:00:41,691]  INFO {org.wso2.carbon.core.transports.http.HttpTransportListener} -  HTTP port        : 9763
[2011-03-16 14:00:42,422]  INFO {org.wso2.carbon.ui.internal.CarbonUIServiceComponent} -  Mgt Console URL  : https://192.168.1.100:9443/carbon/
[2011-03-16 14:00:42,499]  INFO {org.wso2.carbon.core.internal.StartupFinalizerServiceComponent} -  Started Transport Listener Manager
[2011-03-16 14:00:42,500]  INFO {org.wso2.carbon.core.internal.StartupFinalizerServiceComponent} -  Server           :  WSO2 MB -1.0.0-SNAPSHOT
[2011-03-16 14:00:42,506]  INFO {org.wso2.carbon.core.internal.StartupFinalizerServiceComponent} -  WSO2 Carbon started in 27 sec
2011-03-16 14:00:12,471]  INFO {org.wso2.carbon.server.Main} -  Initializing system...

WSO2 Message Broker is installable in more ways for production systems. Typically it is either registered as a Linux Daemon or as a Windows Service – but for now we will stick with the command-line version for simplicity.

Once the server is running you can access the management console. Point your browser at:
            https://localhost:9443

Initially you will see a browser screen warning you about the certificates. Please tell your browser to continue (For a production server you would normally install a proper SSL/TLS certificate, but for initial install we generate a self-signed certificate that you need to agree to use).

Once you have accepted the certificate, you should see a screen like:


You can login using the default user/password which is admin/admin.

Once you login you should see the following screen:


Before we examine the admin console, lets first create a simple JMS client that will communicate with the server via AMQP on TCP/IP.

Getting Started with JMS
The Java Message Service (JMS) specification - http://www.oracle.com/technetwork/java/index-jsp-142945.html - is a specification for talking to message brokers. It is unfortunately poorly named: the word “service” implies this is an implementation, but JMS does not define an actual messaging service, instead just the API which is used to access JMS providers. “Java Messaging API” would more accurately express what JMS is. The result is that there are a variety of JMS providers, and they often have quite different approaches to their core model.

The WSO2 Message Broker is based on the Apache Qpid project (http://qpid.apache.org) and is a compliant implementation of the JMS specification, as well as various levels of the AMQP specification (0-8, 0-9-1, 0-10). 

To write completely standard portable JMS code, you need to use a JNDI provider to gain access to the JMS connection, queues, etc. In this example we will use a Qpid JNDI provider backed by a simple set of properties. This makes the overall system simple and highly portable.

Here is a sample JMS application that can be used to test access to the Message Broker.  You can find this code here:



First are some required imports.

import javax.jms.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import java.util.Properties;

Next is a simple “main” class definition:

public class JMSExample {

public static void main(String[] args) {
       JMSExample producer = new JMSExample();
       producer.runTest();
}

      
private void runTest() {

Since this is just an example, we will place the complete logic in a try/catch block.

try {

Normally the JNDI is configured by a properties file, but you can also do it from an in-memory set of properties. To see a similar setup with a properties file, take a look at the ESB example below.  Here is a properties object to store the properties:

Properties properties = new Properties();

In order to bootstrap the JNDI entries for the connection factory and queue, we set name/value pairs into the simple properties object:                   

properties.put("connectionfactory.cf",
       "amqp://admin:admin@carbon/carbon?brokerlist='tcp://localhost:5672'");

The property name “connectionfactory.cf” denotes that we are creating an object of type ConnectionFactory with name “cf”. The value is a URL that is used to bootstrap the ConnectionFactory: this URL points to the AMQP broker. The syntax is broken up as follows:
       amqp://               Indicates this is an AMQP URL
       admin:admin@  This is the username/password
       carbon/carbon The client ID and virtual host
       ?                     separator for options
       brokerlist=’tcp://localhost:5672’          A list of broker URLs to use

For more information on this URL syntax please see:

The virtual host name is part of the definition in:
/repository/conf/qpid/etc/virtualhosts.xml

This file also defines aspects such as the maximum number of messages in a queue and the queue depth (maximum size in bytes of the queue).

Now we need to create a JNDI entry for the queue we are going to talk to:

properties.put("destination.samplequeue", "samplequeue; {create:always}");

The property name “destination.samplequeue” indicates creating a destination with a JNDI name of “samplequeue”. The property value “samplequeue; {create:always}” indicates a queue named “samplequeue” with an attribute which tells the broker to create the queue if it doesn’t exist.

These properties are specific to the particular JNDI implementation we are using, which is the Qpid “PropertiesFileInitialContextFactory”. So now we need to configure JNDI to use this implementation:
                     
                     
properties.put("java.naming.factory.initial", "org.apache.qpid.jndi.PropertiesFileInitialContextFactory");

Now we can do our JNDI lookups:

Context context = new InitialContext(properties);

ConnectionFactory connectionFactory =
(ConnectionFactory) context.lookup("cf");

Having “found” a JMS Connection Factory in the JNDI, we can now create a connection to the broker:

Connection connection = connectionFactory.createConnection();
connection.start();

And now we can create a JMS Session:

Session session = connection.createSession(false,
                                    Session.AUTO_ACKNOWLEDGE);

One more lookup from JNDI will lookup our queue:

Destination destination = (Destination) context
                                    .lookup("samplequeue");


Now we can create a Producer, and send a message:
                     
MessageProducer producer = session.createProducer(destination);
TextMessage outMessage = session.createTextMessage();
outMessage.setText("Hello World!");
producer.send(outMessage);

Of course, in real life you would most likely NOT now retrieve that same message from the same application, but for this example we will now retrieve the message:                      
MessageConsumer consumer = session.createConsumer(destination);
Message inMessage = consumer.receive();
System.out.println(((TextMessage)inMessage).getText());

And close up the connection and the initial context:
                     
connection.close();
context.close();
} catch (Exception exp) {
       exp.printStackTrace();
}

To try out this client you need the correct client JARs.

In the beta release you will find:
/jms-client-lib/geronimo-jms_1.1_spec-1.1.0.wso2v1.jar
/jms-client-lib/qpid-client-0.9.wso2v2.jar

You also need to reference
/lib/log4j-1.2.13.jar





Once you have those in your classpath you can run the program. You should see some simple output:

log4j:WARN No appenders could be found for logger (org.apache.qpid.jndi.PropertiesFileInitialContextFactory).
log4j:WARN Please initialize the log4j system properly.
Hello World!

If you got that far, congratulations!

In the next section we are going to look at using the ESB with the Message Broker.

There are two approaches for this:
1) If you are using the existing WSO2 ESB 3.0.1 or similar, you can deploy the MB client libraries and communicate using the network.

2) As of the next WSO2 ESB release (3.1.0) it will include the Qpid/MB features as part of the release and you can utilize the Message Broker/JMS runtime locally in the same JVM.

WSO2 MB and WSO2 ESB together
In this first instance we are going to get the WSO2 ESB and MB to work together.
Assuming that you already have the MB installed and running, you will first need to install the ESB and change the ports of the admin console so that they don’t clash. You can download WSO2 ESB 3.0.1 from:
            http://wso2.org/downloads/esb

The install procedure is similar: unzip the ESB, but don’t start it up yet. Let’s name (for this guide) the directory where you installed the ESB as .

First let’s edit the ports on which the ESB listens. (Alternatively you could do the same to the MB instead).

Edit the epositoryconfmgt-transports.xml

This file defines which ports the management console runs (HTTP and HTTPS).

Please change:

<transport name="http" class="org.wso2.carbon.server.transports.http.HttpTransport">
        <parameter name="port">9763</parameter>

to read:
<transport name="http" class="org.wso2.carbon.server.transports.http.HttpTransport">
        <parameter name="port">9764</parameter>

Similarly change the HTTPS port to be 9444.

Now the next step is to ensure that the ESB has the right drivers to talk to the MB. Copy the following JARs into the epositorycomponentslib directory:
/jms-client-lib/geronimo-jms_1.1_spec-1.1.0.wso2v1.jar
/jms-client-lib/qpid-client-0.9.wso2v2.jar


We also need to configure the JMS transport correctly. To do this we edit the axis2.xml file:
  epositoryconfaxis2.xml

This file has the JMS transport commented out. It also needs the settings updated to use the Qpid libraries. Change the file so that the JMS receiver and sender sections look like this:
  
       <transportReceiver name="jms" class="org.apache.axis2.transport.jms.JMSListener">
        <parameter name="myTopicConnectionFactory" locked="false">
         <parameter name="java.naming.factory.initial" locked="false">org.apache.qpid.jndi.PropertiesFileInitialContextFactory</parameter>
         <parameter name="java.naming.provider.url" locked="false">resources/jndi.properties</parameter>
         <parameter name="transport.jms.ConnectionFactoryJNDIName" locked="false">TopicConnectionFactory</parameter>
<parameter name="transport.jms.ConnectionFactoryType" locked="false">topic</parameter>
        </parameter>


        <parameter name="myQueueConnectionFactory" locked="false">
         <parameter name="java.naming.factory.initial" locked="false">org.apache.qpid.jndi.PropertiesFileInitialContextFactory</parameter>
         <parameter name="java.naming.provider.url" locked="false">resources/jndi.properties</parameter>
         <parameter name="transport.jms.ConnectionFactoryJNDIName" locked="false">QueueConnectionFactory</parameter>
<parameter name="transport.jms.ConnectionFactoryType" locked="false">queue</parameter>
        </parameter>


        <parameter name="default" locked="false">
         <parameter name="java.naming.factory.initial" locked="false">org.apache.qpid.jndi.PropertiesFileInitialContextFactory</parameter>
         <parameter name="java.naming.provider.url" locked="false">resources/jndi.properties</parameter>
         <parameter name="transport.jms.ConnectionFactoryJNDIName" locked="false">QueueConnectionFactory</parameter>
<parameter name="transport.jms.ConnectionFactoryType" locked="false">queue</parameter>
        </parameter>
    </transportReceiver>
You can find my copy of the edited axis2.xml here:

If you have looked through the JMS config you will notice it references a JNDI resource: resources/jndi.properties.

This is used to do the same thing the hard-coded properties we used above do – configure the local JNDI that the JMS client inside the ESB will use. In a future release of the ESB we expect to automatically configure this JNDI, but in the meantime, we can simply create a file in the /resources directory.




intro

OAuth2 Introspection with WSO2 ESB and WSO2 Identity Server

The OAuth2 specification defines several parties: the Client, the Resource Owner, the Authorization Server and the Resource Server. Here is the (textual) diagram from the spec:



     +--------+                               +---------------+
     |        |--(A)- Authorization Request ->|   Resource    |
     |        |                               |     Owner     |
     |        |<-(B)-- Authorization Grant ---|               |
     |        |                               +---------------+
     |        |
     |        |                               +---------------+
     |        |--(C)-- Authorization Grant -->| Authorization |
     | Client |                               |     Server    |
     |        |<-(D)----- Access Token -------|               |
     |        |                               +---------------+
     |        |
     |        |                               +---------------+
     |        |--(E)----- Access Token ------>|    Resource   |
     |        |                               |     Server    |
     |        |<-(F)--- Protected Resource ---|               |
     +--------+                               +---------------+

                     Figure 1: Abstract Protocol Flow

One flow that is not defined by the OAuth specification is any flow from the Resource Server to the Authorization server to validate an existing Bearer Token (or other token). 
The spec says:
The interaction between the authorization server and resource server is beyond the scope of this specification.  The authorization server may be the same server as the resource server or a separate entity. A single authorization server may issue access tokens accepted by multiple resource servers.
In many cases the Authorization server offers an API to access this. For example, Google allows you to call a TokenInfo APIto validate tokens. Similarly Facebook offers an API to "debug" a token. The WSO2 Identity Server also offers an API, but (shock and horror) we don't document it yet. The ESB and API manager both utilize this API to validate OAuth2 bearer tokens. The ESB code is of course available, and with a quick look at the code and also the use of TCPMON it didn't take me long to reverse engineer the API. This Gist has a sample HTTP SOAP request against the WSO2 IS to validate a token:
It turns out that the OAuth Working Group at the IETF is working on this and has a draft specification available, using a RESTful service. They call this OAuth Token Introspection. I figured this would be easier (and more pleasant) to call from my Python code, so I knocked up a quick WSO2 ESB API mediation flow to convert from the RESTful API to the existing WSO2 SOAP-based API.
I know that Prabath and the security and identity team at WSO2 will soon add this useful REST API, but in the meantime, here is a quick hack to help you out. Please note you need to hardcode the URL of the IS and the userid/password into the ESB flow. Also I assume if you don't provide a token_type_hint then this is a bearer token. And here is the Gist showing a sample interaction: 




intro

Introducing Text Analytics as a Graduate Business School Course




intro

A Critical Analysis of Active Learning and an Alternative Pedagogical Framework for Introductory Information Systems Courses




intro

Teaching an Introductory Programming Language in a General Education Course




intro

Introducing E-portfolio Use to Primary School Pupils: Response, Benefits and Challenges

Electronic portfolios (e-portfolios) have a positive impact on the learning process in a broad range of educational sectors and on learners of all ages. Yet because most e-portfolio-related studies are about their implementation in higher education, this type of research is less usual in the early childhood context, and there is no available research for Greek schools. This study aims to investigate the impact of e-portfolios on learning in a Greek primary school and to provide a resource regarding the educational benefits of e-portfolio in primary education. To do that, it employs the qualitative naturalistic method to collect data, along with mixed methods which were used to achieve triangulation and strengthen confidence in the outcomes. Participants in the research were fourteen 8-year-old pupils, and one of the researchers was their regular teacher. Data evaluation revealed that the e-portfolio added value in pupils’ learning, acted as a medium to involve parents, promoted pupils’ self-esteem, and was acknowledged as a valuable assessment tool and a challenge for the school community. Based on the experience of the e-portfolio implementation, the authors provide some suggestions that would possibly help researchers and primary school teachers adopt and develop e-portfolio systems in their particular settings.




intro

Introductory Information Systems Course Redesign: Better Preparing Business Students

Aim/Purpose: The dynamic nature of the information systems (IS) field presents educators with the perpetual challenge of keeping course offerings current and relevant. This paper describes the process at a College of Business (COB) to redesign the introductory IS course to better prepare students for advanced business classes and equip them with interdisciplinary knowledge and skills demanded in today’s workplace. Background: The course was previously in the Computer Science (CSC) Department, itself within the COB. However, an administrative restructuring resulted in the CSC department’s removal from the COB and left the core course in limbo. Methodology: This paper presents a case study using focus groups with students, faculty, and advisory council members to assess the value of the traditional introductory course. A survey was distributed to students after implementation of the newly developed course to assess the reception of the course. Contribution: This paper provides an outline of the decision-making process leading to the course redesign of the introductory IS course, including the context and the process of a new course development. Practical suggestions for implementing and teaching an introductory IS course in a business school are given. Findings: Focus group assessment revealed that stakeholders rated the existing introductory IS course of minimal value as students progressed through the COB program, and even less upon entering the workforce. The findings indicated a complete overhaul of the course was required. Recommendations for Practitioners: The subject of technology sometimes requires more than a simple update to the curriculum. When signs point to the need for a complete overhaul, this paper gives practical guidance supplemented with relevant literature for other academicians to follow. Recommendation for Researchers: Students are faced with increasing pressure to be proficient with the latest technology, in both the classroom where educators are trying to prepare them for the modern workplace, as well as the organization which faces an even greater pressure to leverage the latest technology. The newly designed introductory IS course provides students, and eventually organizations, a better measure of this proficiency. Future Research: Future research on the efficacy of this new course design should include longitudinal data to determine the impact on graduates, and eventually the assessment of those graduates’ performance in the workplace.




intro

Redesigning an Introductory Programming Course to Facilitate Effective Student Learning: A Case Study

Aim/Purpose: This study reports the outcome of how a first pilot semester introductory programming course was designed to provide tangible evidence in support of the concept of Student Ownership of Learning (SOL) and how the outcomes of this programming course facilitate effective student learning. Background: Many instructors want to create or redesign their courses to strengthen the relationship between teaching and learning; however, the researchers of this study believe that the concept of Student Ownership of Learning (SOL) connects to student engagement and achievement in the classroom setting. The researchers redesigned the introductory programming course to include valuable teaching methods to increase Student Ownership of Learning and constructive approaches such as making students design an authentic mobile app project as individuals, partners, or within teams. The high quality of students’ projects positioned them as consultants to the university IT department. Methodology: This paper employs a case study design to construct a qualitative research method as it relates to the phenomenon of the study’s goals and lived experiences of students in the redesigned introductory programming course. The redesigned course was marketed to students as a new course with detailed description and elements that were different from the traditional computer science introductory programming course requirement. The redesigned introductory programming course was offered in two sections: one section with 14 registered students and the other section with 15 registered students. One faculty member instructed both sections of the course. A total of 29 students signed up for the newly redesigned introductory programming course, more than in previous semesters, but two students dropped out within the first two weeks of the redesigned course making a total of 27 students. The redesigned coursework was divided into two parts of the semester. The first part of the semester detailed description and elements of the coursework including a redesigned approach with preparation for class, a quiz, and doing homework in class, which gives students control of decisions whenever possible; and working with each other, either with a partner or in a team. The second part of the semester focuses on students designing a non-trivial working mobile app and presenting their developing mobile app at a significant public competition at the end of the semester. Students developed significantly complex mobile apps and incorporated more complex functionality in their apps. Both Management Information System (MIS) major students and Computer Science major students were in the same course despite the fact that MIS students had never taken a programming course before; however, the Computer Science students had taken at least one course of programming. Contribution: This study provides a practical guide for faculty members in Information Technology programs and other faculty members in non-Computer Science programs to create or redesign an introductory course that increases student engagement and achievement in the classroom based on the concept of Student Ownership of Learning (SOL). This study also deepens the discussion in curriculum and instruction on the value to explore issues that departments or programs should consider when establishing coursework or academic programs. Findings: This study found two goals evidently in support to increase Student Ownership of Learning (SOL). The first goal (Increase their ownership of learning SOL) showed that students found value in the course contents and took control of their learning; therefore, the faculty no longer had to point out how important different programming concepts were. The students recognized their own learning gap and were excited when shown a programming concept that addressed the gap. For example, student comments were met with “boy, we can really use this in our app” instead of comments about how complex they were. The coursework produced a desired outcome for students as they would get the knowledge needed to make the best app that they could. The second goal (Develop a positive attitude toward the course) showed positive results as students developed a more positive attitude towards the course. Student actions in the classroom strongly reflected a positive attitude. Attendance was almost 100% during the semester even though no points for attendance were given. Further evidence of Student Ownership of Learning and self-identity was students’ extensive use of the terminology and concept of the course when talking to others, especially during the public competition. Students were also incorporating their learning into their identities. For example, teams became known by their app such as the Game team, the Recipe team, and the Parking team. One team even made team t-shirts. Another exciting reflection of the Student Ownership of Learning which occurred was the learning students did by themselves. Recommendations for Practitioners: Practitioners can share best practices with faculty in different departments, programs, universities, and educational consultants to cultivate the best solution for Student Ownership of Learning based on student engagement and achievement in the classroom setting. Recommendation for Researchers: Researchers can explore different perspectives with scholars and practitioners in various disciplinary fields of study to create or redesign courses and programs to reflect Student Ownership of Learning (SOL). Impact on Society: Student Ownership of Learning is relevant for faculty and universities to incorporate in the creation or redesigning of coursework in academic programs. Readers can gain an understanding that student engagement and achievement are two important drivers of Student Ownership of Learning (SOL) in the classroom setting. Future Research: Practitioners and researchers could follow-up in the future with a study to provide more understanding and updated research information from different research samples and hypotheses on Student Ownership of Learning (SOL).




intro

Towards Understanding Information Systems Students’ Experience of Learning Introductory Programming: A Phenomenographic Approach

Aim/Purpose: This study seeks to understand the various ways information systems (IS) students experience introductory programming to inform IS educators on effective pedagogical approaches to teaching programming. Background: Many students who choose to major in information systems (IS), enter university with little or no experience of learning programming. Few studies have dealt with students’ learning to program in the business faculty, who do not necessarily have the computer science goal of programming. It has been shown that undergraduate IS students struggle with programming. Methodology: The qualitative approach was used in this study to determine students’ notions of learning to program and to determine their cognitive processes while learning to program in higher education. A cohort of 47 students, who were majoring in Information Systems within the Bachelor of Commerce degree programme were part of the study. Reflective journals were used to allow students to record their experiences and to study in-depth their insights and experiences of learning to program during the course. Using phenomenographic methods, categories of description that uniquely characterises the various ways IS students experience learning to program were determined. Contribution: This paper provides educators with empirical evidence on IS students’ experiences of learning to program, which play a crucial role in informing IS educators on how they can lend support and modify their pedagogical approach to teach programming to students who do not necessarily need to have the computer science goal of programming. This study contributes additional evidence that suggests more categories of description for IS students within a business degree. It provides valuable pedagogical insights for IS educators, thus contributing to the body of knowledge Findings: The findings of this study reveal six ways in which IS students’ experience the phenomenon, learning to program. These ways, referred to categories of description, formed an outcome space. Recommendations for Practitioners: Use the experiences of students identified in this study to determine approach to teaching and tasks or assessments assigned Recommendation for Researchers: Using phenomenographic methods researchers in IS or IT may determine pedagogical content knowledge in teaching specific aspects of IT or IS. Impact on Society: More business students would be able to program and improve their logical thinking and coding skills. Future Research: Implement the recommendations for practice and evaluate the students’ performance.




intro

Introducing Instruction into a Personalised Learning Environment




intro

Use of a Class Exercise to Maximize Student Interest in an Introductory MIS Course




intro

Suggested Topics for an IS Introductory Course in Java




intro

Befriending Computer Programming: A Proposed Approach to Teaching Introductory Programming




intro

A Model of Introducing e-Learning System at Vocational College for Business Secretaries




intro

Introducing Students to Business Intelligence: Acceptance and Perceptions of OLAP Software




intro

A Conceptual Model for Learning to Program in Introductory Programming Courses




intro

The Need to Balance the Blend: Online versus Face-to-Face Teaching in an Introductory Accounting Subject




intro

Usability and Pedagogical Assessment of an Algorithm Learning Tool: A Case Study for an Introductory Programming Course for High School

An algorithm learning tool was developed for an introductory computer science class in a specialized science and technology high school in Japan. The tool presents lessons and simple visualizations that aim to facilitate teaching and learning of fundamental algorithms. Written tests and an evaluation questionnaire were designed and implemented along with the learning tool among the participants. The tool’s effect on the learning performance of the students was examined. The differences of the two types of visualizations offered by the tool, one with more input and control options and the other with fewer options, were analyzed. Based on the evaluation questionnaire, the scales with which the tool can be assessed according to its usability and pedagogical effectiveness were identified. After using the algorithm learning tool there was an increase in the posttest scores of the students, and those who used the visualization with more input and control options had higher scores compared to those who used the one with limited options. The learning objectives used to evaluate the tool correlated with the test performance of the students. Properties comprised of learning objectives, algorithm visualization characteristics, and interface assessment are proposed to be incorporated in evaluating an algorithm learning tool for novice learners.




intro

How to Program a Chatbot – An Introductory Project and Student Perceptions

Aim/Purpose: One of the most fascinating developments in computer user interfaces in recent years is the rise of “chatbots”. Yet extent information system (IS) curriculum lacks teaching resources on chatbots programming.. Background: To better prepare students for this new technological development and to enhance the IS curriculum, we introduce a project that teaches students how to program simple chatbots, including a transactional chatbot and a conversational chatbot. Methodology: We demonstrated a project that teaches students how to program two types of simple chatbots: a transactional chatbot and a conversational chatbot. We also conducted a survey to examine students’ perceptions on their learning experience. Findings: Our survey on students’ perception of the project finds that learning chatbots is deemed very useful because chatbot programming projects have enabled the students to understand the subject better. We also found that social influence has positively motivated the students to learn chatbot programming. Though most of the students have no prior experiences programming chatbots, their self-efficacy towards chatbot programming remained high after working through the programming project. Despite the difficult tasks, over 71% of respondents agree to various degrees that chatbot programming is fun. Though most students agree that chatbot programming is not easy to learn, more than 70% of respondents indicated that they will use or learn chatbots in the near future. The overwhelmingly positive responses are impressive given that this is the first time for the students to program and learn chatbots. Recommendations for Practitioners: In this article, we introduced a step by step project on teaching chatbot programming in an information systems class. Following the project instructions, students can get their first intelligent chatbots up and running in a few hours using Slack. This article describes the project in detail as well as students’ perceptions. Recommendations for Researchers: We used UTAUT model to measure students’ perception of the projects. This study could be of value to researchers studying students’ technology learning and adoption behaviors. Impact on Society: To our best knowledge, pedagogical resources that teach IS students how to program chatbots, especially the introductory level materials, are limited. We hope this teaching case could be of value for IS educators when introducing IS students to the wonderful field of chatbot programming. Future Research: For future work, we plan to expand the teaching resources to cover more advanced chatbot programming projects, such as on how to make chatbot more human-like.




intro

Introduction to the Special Section on Game-based Learning: Design and Applications (GbL)




intro

Social Networking, Teaching, and Learning: Introduction to Special Section on Social Networking, Teaching, and Learning (SNTL)




intro

Challenges of Knowledge and Information Management during New Product Introduction: Experiences from a Finnish Multinational Company

Efficient knowledge and information management is essential for companies to prosper in the rapidly changing global environment. This article presents challenges of a large Finnish multinational company relating to their current knowledge and information management practices and systems. The focus is on New Product Introduction (NPI) process. The study is based on interviews and facilitated workshops in the Research and Development (R&D) and Production departments. Furthermore, the identified challenges are reflected to the findings presented in knowledge and information management literature. The results gained from the company case study were well in line with the findings in the literature. Three main topics, which can be generalized to cause challenges for knowledge and information management in most companies, were recognized: 1) Issues related to human behavior, individual characteristics and capabilities, different backgrounds, and professional vocabulary; 2) Codifying tacit knowledge into explicit information, which can be saved to company information system; 3) Lack of interoperability between different information systems. The study provides the management of the case company, and other similar organizations, focus points while seeking for better knowledge and information management. From a scientific perspective, the main contribution of this article is to give practical examples of how the theoretical findings presented in literature manifest themselves in real industrial practices.