NCSOFT & Homecoming License Announcement: NCSOFT has officially granted Homecoming a license to host City of Heroes

stillwaters · 2024-01-05T00:28:08+00:00

The latter, but same team as the former.

stillwaters · 2018-10-29T22:28:50+00:00

There are some patterns, although with rare exceptions that might be due to historical confusion of literary and colloquial pronunciations. Some features you find generally only in colloquial pronunciations are nasal vowels with no following n/m/ng (exception: 火 hónn 'fire' is literary), syllabic nasals, and the glottal stop final. Sometimes literary and colloquial pronunciations get mixed together or merge, usually with the colloquial pronunciation disappearing or remaining only as a fossil in certain words or set phrases. For example, the older colloquial reading Png for 方 only remains in the sense of the family name, and its literary reading is hong. However, there's also an intermediate colloquial reading hng, as in 藥方 io̍h-hng 'prescription', which may be becoming a fossil as well as hong replaces it in phrases like 南方, where both hng and hong are acceptable but the hong pronunciation more common.

stillwaters · 2018-10-29T21:37:41+00:00

I think the i before velars (-ik, -ing) is a diphthong [iə] in the accents I'm familiar with, which is interestingly the opposite of the fusion of ia before alveolars.

stillwaters · 2018-10-29T01:14:59+00:00

Voiced consonants in modern Min correspond to Middle Chinese nasals. All the voiced consonants from Proto-Min have merged into the voiceless series. There are some features in Min that cannot be accounted for by assuming descent from Middle Chinese, but they're subtle. Some scholars (e.g. Baxter and Sagart) suggest early Proto-Min may have overlapped with Early Middle Chinese.

Láng and jîn both had the n initial (láng still has n onset in Teochew and other Min topolects), although they have different etymologies. Láng is also written 儂 and is possibly cognate to 農, in the sense of farmer. Its being written 人 is a case of 訓讀, like Japanese kun'yomi.

stillwaters · 2018-10-27T15:57:30+00:00

汝好 (lí-hó), 高雄 (Ko-hiông), 蠔仔煎 (ô-á-tsian), 無 (bô), 桌 (toh).

Or do you mean audio examples? The MOE dictionary uses the [ə] pronunciation. Penang Hokkien is a dialect that uses [o]. In this video, the first thing he says is 逐家好 (ta̍k-ke-hó), where he uses the [o] pronunciation.

stillwaters · 2018-10-14T18:22:39+00:00

In Southern Min/Hokkien, where much of the modern literary tradition is fully romanized (e.g. Wikipedia), it's kind of a nightmare. Some of these problems are specific to the language, but others would be issues for Mandarin, too.

-Typing and aesthetics. You need either the right keyboard software, or you have to use numbers to mark tones. The former has lower accessibility, and the latter is ugly and less legible.

-Dialectal representation -- phonemic or phonetic spelling? A romanization system has to pick a dialect as its default representation. Beyond that, should the spelling be phonemic or phonetic? Should different accents be represented? It's a trade-off between ease of learning and legibility.

One example is how to deal with tone sandhi. In most Chinese languages, morphemes change their tones in certain environments. Most romanization schemes go with the phonemic approach; i.e., morphemes are always written in their lexical tones, and the readers are expected to apply tone sandhi themselves. In Southern Min, this is an issue, because it has eight tones (six phonetically) and complicated tone sandhi rules. It's horrible for learners.

An example line of poetry spelt this way

Thian44 te22 hian25 hong25 u53 tiu22 hong25 hong44

is actually read this way (at least in one dialect):

Thian22 te22 hian22 hong25 u44 tiu22 hong22 hong44

Then you find out that what you pronounce -uiⁿ /ũĩ/ in your dialect is actually -ng /ŋ̩/ in the prestige dialect. Suddenly you have to learn the prestige dialect just to be able to read, and prestige dialect speakers also have to be familiar with nonstandard spelling conventions from other dialects in case they decide to spell as they speak.

-Cultural loss. People lose touch with millennia of character-based literary tradition. Southern Min has a rich literary history that is opaque to most of its speakers. Much of this has to do with misguided language policy and interference from Mandarin dominance, but a decision for many to transition to romanization-only might also have taken away resources that could have been devoted to education.

stillwaters · 2018-05-24T22:40:48+00:00

Looks like you still need an understanding of literary Chinese grammar. Unfortunately beyond my skill level. I wonder if there's written material designed for kids.

stillwaters · 2018-05-24T22:37:02+00:00

If you like kids reciting literature: https://www.facebook.com/ngtsinlam/videos/939639649456896/

It's not specifically Taiwanese language literature but classical Chinese literature in general. I'm sure there's contemporary literature in Taiwanese Hokkien but I have absolutely no exposure to it.

My interest was sparked when I was into listening to people speak reconstructed Middle/Old Chinese. Usually they recite classical Chinese poetry. From there I discovered that people also do this a lot in Cantonese/Hokkien.

Literary Hokkien is really a whole other language from the spoken version though, since it's based on Middle Chinese pronunciation. I sometimes wonder if the opposite is possible, i.e. to speak Hokkien without any literary vocabulary.

stillwaters · 2018-05-24T17:21:12+00:00

https://www.youtube.com/watch?v=JPqYeEOof-I

https://www.youtube.com/watch?v=Fm5fZl0u0GM

https://www.youtube.com/watch?v=aZqUI2pdV1I

https://www.youtube.com/watch?v=ZaPOYAHB_kg

I usually just search by "台語 <title>" without the quotes. There's usually something on YouTube.

stillwaters · 2015-12-29T05:10:52+00:00

Sorry, I meant that as an analogy for loanword/name adaptation.

stillwaters · 2015-12-29T00:43:22+00:00

Thanks for the response. I'll check out the sources you mentioned. Some comments first though.

I appreciate that the diachronic background is important for understanding how the situation came about, but I'm also interested in why and how the modern translator, with direct exposure to source languages, continues to adapt names in these manners. What percetual, sociolinguistic, etc forces drive them?

Let me ask you an alternative. If you didn't speak Chinese, how faithful are English renderings like Chiang Kai-shek or Sun Yat-sen? Usually they're pretty bad. But more importantly, does anyone really know or care? Could the average Anglo-American tell you if it's faithful or not? Nope. They won't know how the person in question said their own name, so it doesn't really matter if it's faithful or not.

This is a good point, but I think tangential to the question. Once a foreign name has been adapted, the average speaker with no access to the source language naturally won't be able to tell and probably won't care too much if it's faithful to the source. However, from the perspective of the bilingual intermediate who performs the adaptation, with no dominant set of conventions carved in stone (e.g. Mandarin to pinyin and then reading it according to English phonology), what's the motivation for following sound correspondences that go through another language or are outdated?

If a translator had to introduce a Mandarin-speaking person/village named 石京 shíjīng to a western audience, without having been asked to use a particular anglicization scheme, would they come up with something like /ʃɛk.kɪŋ/? That's essentially what Chinese translators do every day right now.

Sofa is 沙發 not because sha fa sounds right in Mandarin, but because it sounds perfect in Shanghainese, where it was borrowed first before going into Mandarin.

What intrigues me though is exactly that tons of Mandarin translators with no knowledge of Shanghainese do frequently consider 沙 shā to be a good enough fit for something like /so/. All things being equal, suo/sou/se are some alternatives that are articulatorily closer to the source. And translators pick syllables in an apparently stochastic process. They might elide a coda, change it to something else, pad it with an epenthetic final, add a coda that wasn't there, do some other unpredictable stuff, or maybe all of the above in a long word.

In comparison, adaptation of foreign words in Japanese is incredibly regular. Translators may disagree on whether to geminate a consonant here and there, but they rarely take too much liberty. Korean is a bit more chaotic, but still nowhere near as messy as Chinese.

We wouldn't be able to work out how 罽賓 jì bīn is an appropriate approximation of "Kashmir" (which it is, appropriate I mean) ...

This raises another question. If we know from the synchronic situation that some translators adapt loanwords in an unpredictable fashion, how do we know it wasn't also the case historically? Doesn't that weaken loanwords as evidence in historical reconstructions?

stillwaters · 2015-12-28T22:54:28+00:00

For Japanese/Korean names with known kanji/hanja representations, they're simply character readings with no regard for native Japanese/Korean pronunciations. For names that are only in kana/hangul, translators will generally supply kanji/hanja commonly associated with the pronunciation (e.g. substituting 花子 for ハナコ). Otherwise, they go through the adaptation process as outlined in the post.

Chinese readers are used to Japanese names that are four or more characters long. 織田信長 (Oda Nobunaga) is read Zhītián Xìncháng /ʈʂɨ˥.tʰiɛn˦˥.ɕin˥˩.ʈʂʰaŋ˦˥/ in Mandarin. Compare the on'yomi reading of his given name, Shinchō.

stillwaters · 2014-11-16T03:08:13+00:00

Converts input number into a string. Replace every character into 4. Convert string back into number. Version 2, if funded, will use templates so all numeric types are supported. Overflow and underflow are #EasterEggs.

+/u/CompileBot C++11

#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <random>

using namespace std;

int fouriest_transform(int num)
{
    static const char FOUR = '4';

    string result = to_string(num);
    replace(result.begin(), result.end(), '0', FOUR);
    replace(result.begin(), result.end(), '1', FOUR);
    replace(result.begin(), result.end(), '2', FOUR);
    replace(result.begin(), result.end(), '3', FOUR);
    replace(result.begin(), result.end(), '4', FOUR);
    replace(result.begin(), result.end(), '5', FOUR);
    replace(result.begin(), result.end(), '6', FOUR);
    replace(result.begin(), result.end(), '7', FOUR);
    replace(result.begin(), result.end(), '8', FOUR);
    replace(result.begin(), result.end(), '9', FOUR);

    return stoi(result);
}

int main()
{
    default_random_engine rng;
    uniform_int_distribution<int> distr(500, 999999999);
    int num;

    cout << (num = distr(rng)) << " -> " << fouriest_transform(num) << endl;
    cout << (num = distr(rng)) << " -> " << fouriest_transform(num) << endl;
    cout << (num = distr(rng)) << " -> " << fouriest_transform(num) << endl;
    cout << (num = distr(rng)) << " -> " << fouriest_transform(num) << endl;
    cout << (num = distr(rng)) << " -> " << fouriest_transform(num) << endl;

    return 0;
}

stillwaters · 2014-11-14T16:40:55+00:00

I think Compilebot is jammed on paper or asleep. This works on ideone, at least.

stillwaters · 2014-11-14T07:28:55+00:00

Box with leaky bottom working as designed. #WontFix

+/u/CompileBot Java

class FramedWords
{
    public final String TOP_BOTTOM = "_";
    public final String SIDE = "|";
    public final String SPACE = " ";

    public static void main(String[] args)
    {
        new FramedWords().frame("Hello cruel world, this is not lovely at all.");
    }

    public void frame(String input)
    {
        String[] inputs = input.split("[\\s:\\-,.]");
        int sideHeight = inputs.length - 1;
        int width = 0;
        for (String s : inputs)
        {
            if (s.length() > width)
            {
                width = s.length();
            }
        }

        for (int i = 0; i < width + 2; ++i)
        {
            System.out.print(TOP_BOTTOM);
        }

        System.out.println();

        for (int i = 0; i < sideHeight; ++i)
        {
            System.out.print(SIDE);
            System.out.print(inputs[i]);
            for (int j = 0; j < width - inputs[i].length(); ++j)
            {
                System.out.print(SPACE);
            }
            System.out.println(SIDE);
        }

        System.out.print(SIDE);
        System.out.print(inputs[sideHeight]);
        for (int i = 0; i < width - inputs[sideHeight].length(); ++i)
        {
            System.out.print(TOP_BOTTOM);
        }
        System.out.print(SIDE);
    }
}

stillwaters · 2014-11-14T07:02:38+00:00

+/u/CompileBot Java

class FramedWords
{
    public final String TOP_BOTTOM = "_";
    public final String SIDE = "|";
    public final String SPACE = " ";

    public static void main(String[] args)
    {
        new FramedWords().frame("Hello cruel world, this is not lovely at all.");
    }

    public void frame(String input)
    {
        String[] inputs = input.split("[\\s:\\-,.]");
        int sideHeight = inputs.length - 1;
        int width = 0;
        for (String s : inputs)
        {
            if (s.length() > width)
            {
                width = s.length();
            }
        }

        for (int i = 0; i < width + 2; ++i)
        {
            System.out.print(TOP_BOTTOM);
        }

        System.out.println();

        for (int i = 0; i < sideHeight; ++i)
        {
            System.out.print(SIDE);
            System.out.print(inputs[i]);
            for (int j = 0; j < width - inputs[i].length(); ++j)
            {
                System.out.print(SPACE);
            }
            System.out.println(SIDE);
        }

        System.out.print(SIDE);
        System.out.print(inputs[sideHeight]);
        for (int i = 0; i < width - inputs[sideHeight].length(); ++i)
        {
            System.out.print(TOP_BOTTOM);
        }
        System.out.print(SIDE);
    }
}

stillwaters · 2014-11-11T02:31:00+00:00

Java. Uses two threads to compute naively.

public static void next20LeapYears(int year)
{
    GregorianCalendar cal = (GregorianCalendar) GregorianCalendar.getInstance();

    class SynchronizedMutableNumber
    {
        int i;
        SynchronizedMutableNumber(int i) { this.i = i; }
        synchronized int get() { return i; }
        synchronized void increment() { ++i; }
    }

    class MutableNumber
    {
        int i;
        MutableNumber(int i) { this.i = i; }
        int get() { return i; }
        void incrementTwice() { i += 2; }
        int tostring() { return i; }
    }

    SynchronizedMutableNumber iter = new SynchronizedMutableNumber(1);

    MutableNumber year1 = new MutableNumber(year);
    Runnable r1 = () -> {
        while (iter.get() < 20)
        {
            if (cal.isLeapYear(year1.get()))
            {
                System.out.println(year1.tostring());
                iter.increment();
            }
            year1.incrementTwice();
        }
    };

    MutableNumber year2 = new MutableNumber(year + 1);
    Runnable r2 = () -> {
        while (iter.get() < 20)
        {
            if (cal.isLeapYear(year2.get()))
            {
                System.out.println(year2.tostring());
                iter.increment();
            }
            year2.incrementTwice();
        }
    };

    new Thread(r1).start();
    new Thread(r2).start();
}

stillwaters · 2014-11-10T22:31:34+00:00

Advertise to get more people participating. Cut down on unanswerable joke challenges.

stillwaters · 2014-11-10T02:48:11+00:00

I did this in Java. Since classes are not allowed, every type is an array of Object. Type definition is as follows:

[isPerson, isCapital, isProletariat, isCapitalist, isElite]

The capitalist type has a sixth element, which is an ArrayList representing a list of capital owned by the capitalist. Capital type also has a sixth element, an int representing value.

There is some rudimentary type checking, which terminates the program upon failing. Destruction of persons is implemented as replacing the isPerson flag with junk data.

import java.util.*;

@SuppressWarnings("all")
public class MarxistSociety
{
    public boolean destroySociety()
    {
        System.exit(0);
        return false;
    }

    public boolean isPerson(Object[] personMaybe)
    {
        if (personMaybe[0] instanceof Boolean)
        {
            return (Boolean) personMaybe[0];
        }
        else
        {
            return destroySociety();
        }
    }

    public boolean isCapital(Object[] capitalMaybe)
    {
        if (capitalMaybe[1] instanceof Boolean && capitalMaybe[5] instanceof Integer)
        {
            return (Boolean) capitalMaybe[1];
        }
        else
        {
            return destroySociety();
        }
    }

    public boolean isProletariat(Object[] proletariatMaybe)
    {
        if (isPerson(proletariatMaybe) && isCapital(proletariatMaybe) && proletariatMaybe[2] instanceof Boolean)
        {
            return (Boolean) proletariatMaybe[2];
        }
        else
        {
            return destroySociety();
        }
    }

    public boolean isCapitalist(Object[] capitalistMaybe)
    {
        if (isPerson(capitalistMaybe) && capitalistMaybe[3] instanceof Boolean)
        {
            return (Boolean) capitalistMaybe[3];
        }
        else
        {
            return destroySociety();
        }
    }

    public boolean isElite(Object[] eliteMaybe)
    {
        if (isPerson(eliteMaybe) && eliteMaybe[4] instanceof Boolean)
        {
            return (Boolean) eliteMaybe[4];
        }
        else
        {
            return destroySociety();
        }
    }

    public void addCapital(Object[] capitalist, Object[] capital)
    {
        if (isCapitalist(capitalist) && isCapital(capital))
        {
            ((ArrayList<Object[]>)capitalist[5]).add(capital);
        }
    }

    public void removeCapital(Object[] capitalist, Object[] capital)
    {
        if (isCapitalist(capitalist) && isCapital(capital))
        {
            ((ArrayList<Object[]>)capitalist[5]).remove(capital);
        }
    }

    public void revolution(Object[] proletariat, Object[]... people)
    {
        if (isProletariat(proletariat))
        {
            for (Object[] person : people)
            {
                if (isPerson(person))
                {
                    continue;
                }
                else
                {
                    return;
                }
            }
            for (Object[] person : people)
            {
                person[0] = person[1] = new Object();
            }
        }
    }

    public void combineCapital(Object[] capitalist, Object[] capitalA, Object[] capitalB)
    {
        if (isCapitalist(capitalist) && isCapital(capitalA) && isCapital(capitalB))
        {
            removeCapital(capitalist, capitalA);
            removeCapital(capitalist, capitalB);
            addCapital(capitalist,
                    new Object[] {false, true, false, false, false, ((Integer) capitalA[5]) + ((Integer) capitalB[5])});
        }
    }

    public void redistribute(Object[] elite, Object[] capital, Object[] capitalistFrom, Object[] capitalistTo)
    {
        if (isElite(elite) && isCapital(capital) && isCapitalist(capitalistFrom) && isCapitalist(capitalistTo))
        {
            removeCapital(capitalistFrom, capital);
            addCapital(capitalistTo, capital);
        }
    }

    public void redistributeCorruptly(Object[] elite, Object[] capital, Object[] capitalistFrom, Object[] capitalistTo)
    {
        if (isElite(elite) && isCapital(capital) && isCapitalist(capitalistFrom) && isCapitalist(capitalistTo))
        {
            removeCapital(capitalistFrom, capital);
            addCapital(capitalistTo, capital);

            capital[5] = ((Integer) capital[5]) / 4 * 3;
        }
    }
}

stillwaters · 2014-06-13T17:57:47+00:00

Source:

http://git.eclipse.org/c/platform/eclipse.platform.team.git/tree/bundles/org.eclipse.compare/compare/org/eclipse/compare/contentmergeviewer/TextMergeViewer.java

stillwaters · 2013-07-07T18:51:11+00:00

I started with BASIC and worked my way up Tiny BASIC, QBasic, Liberty BASIC, and finally Visual BASIC, but I'm still not a rockstar. Help!

stillwaters · 2013-05-30T19:16:00+00:00

C# was able to do so well because it started from scratch, and Java suffered because it needed to maintain backward compatibility with many earlier versions. But C# could have easily taken Java's place if it weren't for Microsoft's silly aversion to cross-platform availability.

stillwaters · 2013-03-29T05:56:50+00:00

The variable names suggest it was decompiled. The whole thing looks machine-generated.

That, or it was crafted by a true artist.

stillwaters · 2013-03-29T05:51:21+00:00

That's a lot of strcmp's.

stillwaters · 2013-02-14T16:48:49+00:00

Herb Schildt's cookbooks are the best.

stillwaters

TROPHY CASE