Friday, July 31, 2015

Fwd: A card for you to make you smile!



Sent from my iPad

Begin forwarded message:

From: Dolores Kuo <doloresmkuo@gmail.com>
Date: July 31, 2015 at 8:20:59 PM CDT
To: Jensie Tou <pandjtou@aol.com>, "ronny_lin@hotmail.com" <ronny_lin@hotmail.com>,  Nancy Chao <nancyhychao@yahoo.com>, Tina Soong <tsoongtotherim@aol.com>,  Chris Wang <chriswang_95051@yahoo.com>, Charlotte Tao <charlottetao1@gmail.com>
Subject: Fwd: A card for you to make you smile!



---------- Forwarded message ----------
From: anna4cheng@gmail.com <anna4cheng@gmail.com>
Date: Friday, July 31, 2015
Subject: Fwd: A card for you to make you smile!
To: Jenmay Wang <jmw_pw@msn.com>




Sent from my iPhone



Subject: A card for you to make you smile!
Date: Thu, 30 Jul 2015 09:08:03 -0400
From: tampajuice@tampajuice.com

 

 

 

 

                                                                THANK YOU FOR BEING MY FRIEND

 

                     A card for you to make you smile ...

Tough times never last, tough people do.   
FE1949816DFA4AD78E036AB457D05225@DF1TMP61  My Friend!   

Thought For The Day:

GOOD looks catch the eye but a GOOD
personality catches the heart.

You're blessed with    both!'

  2AE15B30EDA04131AE10CBD524527055@DF1TMP61



It's "Friends Day" -
Send this to all your good friends.
if I am one of them.
See how many you get back.
If you get more than 3,
you are really a lovable person

..................... 

WELL!  Don't just sit there! Your friends are waiting for something
to LIFT THEM UP!  That would be kind words from you!

 

                            God Bless America!

 





--
Sent from My iPad
Posted by at No comments:

Digest for comp.lang.c++@googlegroups.com - 13 updates in 3 topics

Doug Mika <dougmmika@gmail.com>: Jul 31 11:15AM -0700

On Thursday, July 30, 2015 at 5:41:32 PM UTC-5, Victor Bazarov wrote:
 
> V
> --
> I do not respond to top-posted replies, please don't ask
 
I'm reading C++ Concurrency in Action: Practical Multithreading by Anthony Williams. Any other you would suggest?
Doug Mika <dougmmika@gmail.com>: Jul 31 11:37AM -0700

On Thursday, July 30, 2015 at 4:59:49 PM UTC-5, Doug Mika wrote:
> ..
> }
 
> in a mutex to ensure that only one thread executes it at a time. Is there another neat/quick way to achieve what I'm trying to do?
 
 
I guess what I wanted to ask is is there a structure/way in C++ to "bundle" commands into "one" command ensuring that once I start executing the first command that no thread will interrupt until I execute the last command in the bundle?
 
ie.
/*beginning of bundle*/
if(!stack.empty()){
/*some code*/
stack.pop();
}
/*end of bundle*/
 
out of the collection of commands I wanted to create "one command" that is guaranteed to be executed without interruptions by ANY other thread?
scott@slp53.sl.home (Scott Lurndal): Jul 31 06:55PM

>}
>/*end of bundle*/
 
>out of the collection of commands I wanted to create "one command" that is guaranteed to be executed without interruptions by ANY other thread?
 
The "proper" way would be for the stack object
to provide thread-safe methods. That means the
stack object needs to handle concurrent access
to the stack internally, using whatever synchronization
mechanism makes sense for the application.
 
The simplest is to use a mutex (e.g. pthread_mutex std::mutex) within
the ::push, ::pop and ::emtpy methods to protect access
to the underlying data structure used to represent a
stack of objects.
 
It's not a good idea to do the synchronization outside of
the stack object.
 
e.g.:
 
void
Stack::push(T& obj)
{
std:lock_guard<std::mutex> lock(_mutex); // _mutex is private class member std::mutex
<push item on stack>
}
 
void
Stack::pop(T& obj)
{
std::lock_guard<std::Mutex> lock(_mutex);
<pop item from stack>
}
Victor Bazarov <v.bazarov@comcast.invalid>: Jul 31 03:10PM -0400

On 7/31/2015 2:15 PM, Doug Mika wrote:
>> --
>> I do not respond to top-posted replies, please don't ask
 
> I'm reading C++ Concurrency in Action: Practical Multithreading by Anthony Williams. Any other you would suggest?
 
It's a good book, I've no doubt.
 
I started learning multithreading while doing it in Java, and for that I
bought "Java Thread Programming" by Paul Hyde (I picked it up in a local
bookstore at the time after browsing for a few minutes). There are
better books out there, probably. There is no single true source of
knowledge, as you are certainly already aware.
 
Right now on my shelf I have also "Patterns for Parallel Programming",
"Parallel Programming with Microsoft Visual C++", "The Art of
Multiprocessor Programming", "Intel Thread Building Blocks" (probably
already obsolete), and "Software Optimization for High Performance
Computing" (from HP Professional Books series). Sadly, I don't get to
open them for what I am doing nowadays...
 
V
--
I do not respond to top-posted replies, please don't ask
Victor Bazarov <v.bazarov@comcast.invalid>: Jul 31 03:12PM -0400

On 7/31/2015 2:37 PM, Doug Mika wrote:
> On Thursday, July 30, 2015 at 4:59:49 PM UTC-5, Doug Mika wrote:
>> [...]
> I guess what I wanted to ask is is there a structure/way in C++ to
"bundle" commands into "one" command ensuring that once I start
executing the first command that no thread will interrupt until I
execute the last command in the bundle?
 
> out of the collection of commands I wanted to create "one command"
> that is guaranteed to be executed without interruptions by ANY other
> thread?
 
See "Critical Section".
 
V
--
I do not respond to top-posted replies, please don't ask
Victor Bazarov <v.bazarov@comcast.invalid>: Jul 31 03:17PM -0400

On 7/31/2015 2:55 PM, Scott Lurndal wrote:
> std::lock_guard<std::Mutex> lock(_mutex);
> <pop item from stack>
> }
 
This is not enough. If the stack reports that it's not empty, then the
code that learned that the stack is not empty starts doing something
hoping that the stack remains non-empty, and another thread pops the
last element from the stack, it can easily interfere with the code that
presumes the stack non-empty until it's time to pop.
 
This is what critical sections are for, IMHO. It's not the best
solution, of course. A better solution would be to refactor the code so
that it doesn't need to keep others from accessing the stack. That's
why I asked Doug about the contents of his ".." in the original post,
but got no answer.
 
V
--
I do not respond to top-posted replies, please don't ask
Christopher Pisz <nospam@notanaddress.com>: Jul 31 02:36PM -0500

On 7/31/2015 2:17 PM, Victor Bazarov wrote:
> why I asked Doug about the contents of his ".." in the original post,
> but got no answer.
 
> V
 
 
I remember running into that. I think we added a lock and unlock to the
interface on top of what was there for such scenarios and would rely on
the internal locks for most things, but lock it externally for things
that would depend on empty or size for logic involving other stack
operations.
 
 
 
--
I have chosen to troll filter/ignore all subthreads containing the
words: "Rick C. Hodgins", "Flibble", and "Islam"
So, I won't be able to see or respond to any such messages
---
scott@slp53.sl.home (Scott Lurndal): Jul 31 08:05PM

>hoping that the stack remains non-empty, and another thread pops the
>last element from the stack, it can easily interfere with the code that
>presumes the stack non-empty until it's time to pop.
 
That's a different mutex. The stack mutex protects the stack.
 
A higher level mutex protects the algorithm that uses the stack.
Doug Mika <dougmmika@gmail.com>: Jul 31 01:41PM -0700

On Thursday, July 30, 2015 at 4:59:49 PM UTC-5, Doug Mika wrote:
> ..
> }
 
> in a mutex to ensure that only one thread executes it at a time. Is there another neat/quick way to achieve what I'm trying to do?
 
.. was to be ANY code you could think of that made sense.
woodbrian77@gmail.com: Jul 30 10:07PM -0700

http://stackoverflow.com/questions/31711261/c-standard-serializtion
 
The OP may find the C++ Middleware Writer to be of interest.
He says he's not interested in JSON or XML.
 
 
Brian
Ebenezer Enterprises - In G-d we trust.
http://webEbenezer.net
"Öö Tiib" <ootiib@hot.ee>: Jul 31 08:45AM -0700

> http://stackoverflow.com/questions/31711261/c-standard-serializtion
 
> The OP may find the C++ Middleware Writer to be of interest.
> He says he's not interested in JSON or XML.
 
Uh? Is it Sabbath so you may not contact him nor ask our
help? I doubt if he wants your tool. He writes that he is
16 years old guy who only recently started with C++ and
is a firm follower of NIH policy.
 
Your tool sort of contradicts with NIH policy.
Perhaps you can help him to write his own
Yet_Another_My_Middleware_Exchange_Rocket.
"R. Schubert" <raphael.schubert@gmx.de>: Jul 31 02:03AM -0700

On Friday, July 31, 2015 at 1:33:26 AM UTC+2, Christopher Pisz wrote:
> words: "Rick C. Hodgins", "Flibble", and "Islam"
> So, I won't be able to see or respond to any such messages
> ---
 
You could do it similarly to the example here
http://en.cppreference.com/w/cpp/locale/ctype
"Öö Tiib" <ootiib@hot.ee>: Jul 31 04:58AM -0700

On Friday, 31 July 2015 02:33:26 UTC+3, Christopher Pisz wrote:
> Is there a way to set the delimeter for an istringstream when using the
> '>> operator'?
 
> I prefer to not use getline if possible.
 
Copy-paste of accepted answer from
 
http://stackoverflow.com/questions/10376199/how-can-i-use-non-default-delimiters-when-reading-a-text-file-with-stdfstream
 
It looks fine.
 
#include <locale>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <vector>
#include <sstream>
 
class my_ctype
: public std::ctype<char>
{
mask my_table[table_size];
public:
my_ctype(size_t refs = 0)
: std::ctype<char>(&my_table[0], false, refs)
{
std::copy_n(classic_table(), table_size, my_table);
my_table['-'] = (mask)space;
my_table['\''] = (mask)space;
}
};
 
// test
int main()
{
std::istringstream input("This is some input from McDonald's and Burger-King.");
std::locale x(std::locale::classic(), new my_ctype);
input.imbue(x);
 
std::copy(std::istream_iterator<std::string>(input),
std::istream_iterator<std::string>(),
std::ostream_iterator<std::string>(std::cout, "\n"));
 
return 0;
}
 
Output:
 
This
is
some
input
from
McDonald
s
and
Burger
King.
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at No comments:

Digest for comp.programming.threads@googlegroups.com - 2 updates in 1 topic

Behrooz Amoozad <behrooz0az@gmail.com>: Jul 30 04:05AM -0700

Impressive, comp.programming.threads. I don't think there are more than a dozen topics hardar than this in programming. and this question.
if you don't know where to ask you have no business modifying compiled code.
Behrooz Amoozad <behrooz0az@gmail.com>: Jul 30 04:05AM -0700

Impressive, comp.programming.threads. I don't think there are more than a dozen topics hardar than this in programming. and this question.
if you don't know where to ask you have no business modifying compiled code.
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.programming.threads+unsubscribe@googlegroups.com.
Posted by at No comments:

Thursday, July 30, 2015

Digest for comp.lang.c++@googlegroups.com - 6 updates in 3 topics

Doug Mika <dougmmika@gmail.com>: Jul 30 02:59PM -0700

Let me first illustrate the simple problem:
 
If I have a stack data structure accessed by two threads and the following code that runs on both threads:
 
if(!stack.empty()){
..
stack.pop();
..
}
 
then I may encounter a problem if thread A executes pop() after thread B passes the if statement. That is, there is a chance that if I have one element on my stack, that both threads may execute pop() on it.
 
The simple solution that comes to my mind is to wrap this entire block of code:
 
if(!stack.empty()){
..
stack.pop();
..
}
 
in a mutex to ensure that only one thread executes it at a time. Is there another neat/quick way to achieve what I'm trying to do?
Victor Bazarov <v.bazarov@comcast.invalid>: Jul 30 06:41PM -0400

On 7/30/2015 5:59 PM, Doug Mika wrote:
> Let me first illustrate the simple problem:
 
> If I have a stack data structure accessed by two threads and the
following code that runs on both threads:
> }
 
> then I may encounter a problem if thread A executes pop() after
> thread
B passes the if statement. That is, there is a chance that if I have one
element on my stack, that both threads may execute pop() on it.
 
> The simple solution that comes to my mind is to wrap this entire
> block
of code:
> }
 
> in a mutex to ensure that only one thread executes it at a time. Is
> there another neat/quick way to achieve what I'm trying to do?
 
What do the dots designate in your example? Some other processing?
Does it only happen if the stack is not empty? If you make this
processing exclusive (with a mutex or critical section or a semaphore),
in other words if you make it synchronous, will it be a performance
bottleneck? If not, it's probably OK to lock the whole thing.
 
What book are you reading on threads? What do they say about such
situations?
 
BTW, have you found 'comp.programming.threads' newsgroup yet?
 
V
--
I do not respond to top-posted replies, please don't ask
Ian Collins <ian-news@hotmail.com>: Jul 31 10:42AM +1200

Doug Mika wrote:
 
> if(!stack.empty()){ .. stack.pop(); .. }
 
> in a mutex to ensure that only one thread executes it at a time. Is
> there another neat/quick way to achieve what I'm trying to do?
 
Please wrap your lines!
 
Use a condition variable with !stack.empty() as the condition.
 
--
Ian Collins
Christopher Pisz <nospam@notanaddress.com>: Jul 30 06:43PM -0500

On 7/30/2015 4:59 PM, Doug Mika wrote:
> ..
> }
 
> in a mutex to ensure that only one thread executes it at a time. Is there another neat/quick way to achieve what I'm trying to do?
 
If I have some data structure that I am going to share between thread, I
prefer to make my own class, write the same interface, make the original
data structure a private member, and then have the class I wrote control
the data and the mutex.
 
Incomplete example:
 
template <T> class ConcurrentStack
{
public:
void push(const T & value)
{
m_mutex.lock();
m_stack.push(value);
m_mutex.unlock();
}
 
T pop()
{
m_mutex.lock();
T value(m_stack.pop());
m_mutex.unlock();
 
return value;
}
 
private:
std::stack<T> m_stack;
std::mutex m_mutex;
};
 
basic idea...I'm sure you can make it more efficient and take care of
the nuances from there.
 
I keep a concurrent library in my common code for such things. I like my
container to own its own mutex rather than someone else and especially
rather than a whole bunch of people trying to lock and unlock it. This
way, no one need worry about the fact that there is a mutex, threads
must simply be aware that they have to wait via the documentation.
 
 
--
I have chosen to troll filter/ignore all subthreads containing the
words: "Rick C. Hodgins", "Flibble", and "Islam"
So, I won't be able to see or respond to any such messages
---
Christopher Pisz <nospam@notanaddress.com>: Jul 30 06:33PM -0500

Is there a way to set the delimeter for an istringstream when using the
'>> operator'?
 
I prefer to not use getline if possible.
 
 
--
I have chosen to troll filter/ignore all subthreads containing the
words: "Rick C. Hodgins", "Flibble", and "Islam"
So, I won't be able to see or respond to any such messages
---
"Öö Tiib" <ootiib@hot.ee>: Jul 30 12:23AM -0700

On Wednesday, 29 July 2015 02:18:33 UTC+3, Alf P. Steinbach wrote:
> nodes. At the coding/implementation level it's inappropriate because
> it's more verbose and hence less maintainable code, and also (but
> secondary) just needless memory and possibly execution time overhead.
 
There may be cases where such design makes best sense and when it
makes sense then it usually simplifies coding as well. I can think of
two:
 
1) Case when element is most logical owner of next element.
Singly linked list is technically subcase of tree. Sort of one-branched tree.
If trunk interacts with its branch then a reference makes sense. If trunk
owns the branch then smart pointer makes sense as that reference.
 
2) Case when neither elements nor the list own elements.
Elements are owned by something outside but sometimes form such
temporary lists. Intrusive list may perform better and make better sense
than list of pointers. Non-owning 'std::unique_ptr' may be used there as
link between elements to signal the "something outside" that element has
left such list.
 
Performance-wise there is very little difference between 'unique_ptr' and
raw ... it is 'shared_ptr' that is fat.
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at No comments:

Wednesday, July 29, 2015

Digest for comp.lang.c++@googlegroups.com - 4 updates in 1 topic

Paul <pepstein5@gmail.com>: Jul 28 02:38PM -0700

Elements of Programming Interviews gives the following code for merging linked lists. My questions are: Is it ok for merge_sorted_linked_lists to use call by reference instead of call by value? Also, are std::unique_ptr or raw pointers ok besides the author's use of shared pointers? Would unique pointers be preferable?
Can we use unique pointers by simply using std::move for every assignment? For example, if we use unique pointers, do we replace tail->next = n; by tail->next = std::move(n); Does that approach work straightforwardly or are there complications, necessitating shared instead of unique pointers?
Many thanks for your help.
 
Paul
 
BEGIN QUOTE
template <typename T>
void append_node(shared_ptr<node_t<T> >& head, shared_ptr<node_t<T> >& tail,
shared_ptr<node_t<T> >& n)
{
head ? tail->next = n : head = n;
tail = n;
}
 
template <typename T>
void append_node_and_advance(shared_ptr<node_t<T> >& head, shared_ptr<node_t<T> >& tail,
shared_ptr<node_t<T> >& n)
{
append_node(head, tail, n);
n = n->next;
}
 
template <typename T>
shared_ptr<node_t<T> > merge_sorted_linked_lists(shared_ptr<node_t<T> F>, shared_ptr<node_t<T> > L)
{
shared_ptr<node_t<T> sorted_head = nullptr, tail = nullptr;
 
while(F&&L)
append_node_and_advance(sorted_head, tail, F->data < L->data ? F : L);
if(L)
append_node(sorted_head, tail, L);
 
if(F)
append_node(sorted_head, tail, F);
 
return sorted_head;
 
}
 
}
Paul <pepstein5@gmail.com>: Jul 28 02:44PM -0700

On Tuesday, July 28, 2015 at 10:39:11 PM UTC+1, Paul wrote:
> Can we use unique pointers by simply using std::move for every assignment? For example, if we use unique pointers, do we replace tail->next = n; by tail->next = std::move(n); Does that approach work straightforwardly or are there complications, necessitating shared instead of unique pointers?
> Many thanks for your help.
 
> Paul
 
I see some typos in the above code. Sorry, I'll try to correct these.
 
template <typename T>
void append_node(shared_ptr<node_t<T> >& head, shared_ptr<node_t<T> >& tail,
shared_ptr<node_t<T> >& n)
{
head ? tail->next = n : head = n;
tail = n;
}
 
template <typename T>
void append_node_and_advance(shared_ptr<node_t<T> >& head, shared_ptr<node_t<T> >& tail,
shared_ptr<node_t<T> >& n)
{
append_node(head, tail, n);
n = n->next;
}
 
template <typename T>
shared_ptr<node_t<T> > merge_sorted_linked_lists(shared_ptr<node_t<T> > F, shared_ptr<node_t<T> > L)
{
shared_ptr<node_t<T> > sorted_head = nullptr, tail = nullptr;
 
while(F&&L)
append_node_and_advance(sorted_head, tail, F->data < L->data ? F : L);
if(L)
append_node(sorted_head, tail, L);
 
if(F)
append_node(sorted_head, tail, F);
 
return sorted_head;
 
}
 
}
Paul <pepstein5@gmail.com>: Jul 28 02:48PM -0700

On Tuesday, July 28, 2015 at 10:44:44 PM UTC+1, Paul wrote:
...
Hopefully, final attempt to get this right:
 
template <typename T>
void append_node(shared_ptr<node_t<T> >& head, shared_ptr<node_t<T> >& tail,
shared_ptr<node_t<T> >& n)
{
head ? tail->next = n : head = n;
tail = n;
}
 
template <typename T>
void append_node_and_advance(shared_ptr<node_t<T> >& head, shared_ptr<node_t<T> >& tail,
shared_ptr<node_t<T> >& n)
{
append_node(head, tail, n);
n = n->next;
}
 
template <typename T>
 
shared_ptr<node_t<T> > merge_sorted_linked_lists(shared_ptr<node_t<T> > F, shared_ptr<node_t<T> > L)
 
 
{
shared_ptr<node_t<T> > sorted_head = nullptr, tail = nullptr;
 
while(F&&L)
append_node_and_advance(sorted_head, tail, F->data < L->data ? F : L);
if(L)
append_node(sorted_head, tail, L);
 
if(F)
append_node(sorted_head, tail, F);
 
return sorted_head;
 
}
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Jul 29 01:18AM +0200

On 28-Jul-15 11:38 PM, Paul wrote:
> are std::unique_ptr or raw pointers ok besides the author's use of shared pointers?
 
I can't think of any application of a DIY linked list where smart
pointers would be appropriate for linking up the nodes. At the design
level it's inappropriate because the linked list is an owner of its
nodes. At the coding/implementation level it's inappropriate because
it's more verbose and hence less maintainable code, and also (but
secondary) just needless memory and possibly execution time overhead.
 
However, no rule without exception.
 
But on the third and gripping hand, the question is not whether raw
pointers are OK, it's whether the author's use of shared pointers is OK,
and that's at least highly questionable.
 
Cheers & hth.,
 
- Alf
 
--
Using Thunderbird as Usenet client, Eternal September as NNTP server.
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at No comments:

Fwd: 李登輝日本演講∕大家好，我是來自台灣的岩里正男

    他原就是倭寇派来臥底的吧？

  
Subject: Fwd: 李登輝日本演講∕大家好，我是來自台灣的岩里正男




Subject: 李登輝日本演講∕大家好，我是來自台灣的岩里正男

他只會吃中國台灣的飯，喝中國台灣的水，又伸手拿中國台灣的俸養，頂著中國台灣的官，又持著中國台灣的護照，卻去日本認賊作父，甘為倭奴，歷史上沒有一個漢奸有他這份能耐！

這隻狗畜牲簡直是不要臉，外加無恥 ! 台灣的民進黨怎盡出這種史無前例賣國的敗類?
台灣的中國人，台灣的政府是怎麼回事? 是不是全都發了瘟?
他還有臉回台灣，台灣又怎能讓他回來? 


李登輝日本演講／大家好，我是來自台灣的岩里正男

2015-07-24 02:24:50 聯合報 童舟／文字工作者（台北市）

李登輝在日本演講。開場白是：大家好，我是來自台灣的李登輝。

從通篇講辭表露的飛揚意態顯示，這句開場白的原型其實是：大家好，我是來自台灣的岩里正男。

講辭描述一個皇民被棄在台灣島後的傳奇人生，以及衣錦還鄉日本祖國的榮耀與驕傲。李登輝告訴日本人：日本雖將台灣失於中國，但他已將台灣自中國奪回。


 

前總統李登輝22日在日本國會議員會館發表演講，講題是「台灣典範的轉移」。東京記者雷光涵／攝影

分享
講辭的主要內容有三：一、自我標榜受日本教養的李登輝對台灣「脫古改新」的貢獻。二、抹煞及詆譭「中華民國」。三、主張切斷台灣與「中國」的關聯。

李登輝稱中華民國為「外來政權」，指在中華民國統治下「台灣人還是存在奴隸般的狀況」，並將台灣民主化的成就幾乎完全歸功於李登輝自己一人。

但是，台灣的民主化主要是在蔣氏二代的三部曲下實現。一、禁止它（民主）發生；二、準備它（民主）發生；三、使它（民主）發生。

可以斷言，若無蔣經國「分期付款式的民主」之持續進行，並在一九八七年宣布解嚴（使民主發生），李登輝自述的那段民主變革皆失憑藉。李登輝揚言「脫古」，但不能否認蔣經國在準備台灣民主化，及使台灣民主化發生，並為李登輝奠基的重大角色。這是「脫」不了的「古」，而這些也是中華民國的歷史成就。

通篇講辭，對中華民國外來政權及國民黨的治理評價，只有「台灣人還是存在奴隸般的狀況」十三個字。固然，那段期間，確有可以批評或譴責之處，如二二八、白色恐怖等；但若在通篇講辭中，為了「脫古」，僅以「台灣人存在於奴隸般的狀況」一筆概括中華民國，則不僅是以偏概全，更不啻是信口雌黃。

其實，在蔣經國將中華民國交付於李登輝之手時，就當時的國際標準言，台灣在各方面的表現皆在國際標準的中等以上，尤以經濟面論，更為亞洲四小龍之首。這些，皆是蔣經國留給李登輝的「由準備它（民主）發生，至使它（解嚴民主化）發生」的政治遺產，而不能視為「奴隸台灣人」的罪證。

不說別的，蔣經國將政權交給曾為日本皇民及曾為中共黨員的台灣人李登輝手中，不外亦是出自「民主化／本土化」的正大思考；難道為了「脫古」，也能將其包括在「台灣人還是存在奴隸狀況中」嗎？

李登輝遮蔽了蔣經國在民主化上「準備它發生／使它發生」的角色，抹煞及遮蓋了中華民國與國民黨在台灣的一切正面貢獻（例如：三七五減租／耕者有其田／地方自治／加工出口區／九年國教／十大建設／科學園區／國會增補選／公保、勞保／科學園區／勞動基準法／解嚴／開放兩岸交流等），一概皆用「奴隸狀況」一言以「蔽」之。於是，李登輝恬不知恥地說，直至一九九六年他主持總統直選，「（台灣才）正式脫離外來政權的統治」。此說若真，李登輝在一九九六年以前，他還有八年在頭上頂著「外來政權中華民國總統」的職銜。

李登輝自我標榜其民主變革及修憲功勛，謂為「一生的榮譽與驕傲」。但即以修憲言，他在講辭中也承認，他所主導的新憲「對總統的權力範圍沒有明確規範」「完全端視總統個人民主素養和自制力的狀態（而定）」。這可視為李登輝在通篇講辭中唯一認錯之處，事實上，他操弄憲法：一、在體制上，修出了一部總統無權無責，又可濫權卸責的惡憲（為他自己量身裁製？）二、在實際憲政上，李登輝甚且正是「個人民主素養和自制力狀態」極為低劣的總統。在李登輝十二年總統任內，「政治」即是「權謀鬥爭」的同義詞。但是，他以修憲搞砸了「第一次民主改革」，如今竟又倡議再修憲的「第二次民主改革」。何其可哂？

李登輝用他切割得七拼八湊的歷史，來補綴他自己顛三倒四的人生，有何意義？沒有蔣經國的「古」，何來李登輝的「新」？何況，稱「李前中華民國」為外來政權，而稱「李後中華民國」不是外來政權，除了用來詆譭中華民國以外，對於台灣所面對的今日及未來之內外困局，難道就能展現一套「脫古改新」生存大戰略？

李登輝提出「脫古改新」的台灣生存大戰略，是要切斷「一個中國」的關聯，「朝向擺脫『一個中國』，以及終止『中國法統』的道路邁進」。這就是台獨，但李登輝在通篇講辭中未說出「台灣獨立」四字。這無論是因他說不出口，或不敢說，皆不僅是欲言又止，而根本已是不能自圓其說。

李登輝講辭的標題是《台灣的典範轉移》，論述主軸為「脫古改新」。其實，這正是「中華民國典範」與「台灣（台獨）典範」的大思考；就台灣的生存戰略言，亦即是「中華民國路線」與「台獨路線」的大抉擇。

通篇講辭顯示，李登輝所稱的「脫古改新」，就是要「脫中華民國戰略路線（古）」，「改台獨戰略路線（新）」。這是拾「台獨典範」唾餘之「古」，來矯創其「台灣典範」之「新」。

李登輝認為，唯有「台灣（台獨）典範」始能建立台灣的主體性，即可「擺脫一個中國」。但是，主張「中華民國典範」，難道就不能建立台灣的主體性嗎？這不僅是兩種「典範」的差異，更是兩種「國家生存戰略」的抉擇。如果李登輝所稱的「台灣典範」可以成為台灣的生存戰略，何不即明火執仗地高舉「台獨典範」？

這是李登輝欲言又止的原因，更是岩里正男不能自圓其說的底蘊。

脫古改新。但李登輝不僅病在「不識古」，尤其害在「不知新」。在今日世局、兩岸及中華民國國情的「新」局下，妄論回復台獨路線之「古」，正是害在不知今朝何日。而以中華民國退任總統李登輝的身分，為皇民岩里正男發表返鄉報告，尤是病在不知今夕何夕。

李登輝反對「托古改制」，卻托台獨之「古」，欲篡改中華民國之「制」。此種「脫古改新」，其實是李登輝與岩里正男的古今矛盾之映射。





















Posted by at No comments:

Fwd: Photos and Words of Truth



Sent from my iPad

Begin forwarded message:

From: "Pat Shumard" <pshumard@cox.net>
Date: July 29, 2015 at 1:27:25 PM CDT
To: "Andrea weed" <awsimmental@gmail.com>, "Bridget" <bj3672@yahoo.com>, "Carrie Herzberg" <bherzberg@cox.net>, "Gladys Schupbach" <sissy-gms@live.com>, "Janet" <dawgbob@sbcglobal.net>, "Kellie Lewis" <vetmedkl@vet.ksu.edu>, "Margie Barr" <margiebarr17@gmail.com>, "Mary Jane" <lmeyer004@centurytel.net>, "MIKE" <mlmcarthur@yahoo.com>, "Pat A" <headbookworm@yahoo.com>, "Richard Drown" <rdrown@cox.net>, "Robert McArthur" <rsm0761@cox.net>, "Ron" <rtriper@hughes.net>, "sharon norton" <norton3608@yahoo.com>, "susan Cooper" <slcooper123@hotmail.com>, "tien" <tsoongtotherim@aol.com>, "Tracie Shumard" <mypeanut1218@yahoo.com>
Subject: Fw: Photos and Words of Truth

 
 
 
Photos and Words of Truth
 
 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 





 

 
 
 
 


Avast logo

This email has been checked for viruses by Avast antivirus software.
www.avast.com


Posted by at No comments:

Tuesday, July 28, 2015

Fwd: 黃智賢建議 把李登輝移交日本永久託管



Sent from my iPad

Begin forwarded message:

From: Tina Soong <tinasoong@att.net>
Date: July 27, 2015 at 4:29:34 PM CDT
To: nsoong21@gmail.com
Subject: Fwd: 黃智賢建議 把李登輝移交日本永久託管



Sent from my iPad

Begin forwarded message:

From: Hsiao-Hung <k6hsi@aol.com>
Date: July 27, 2015 at 8:37:13 AM CDT
Subject: Fwd: 黃智賢建議 把李登輝移交日本永久託管



黃智賢建議 把李登輝移交日本永久託管


2015年07月26日 14:28

    作家黃智賢今日在臉書中表示，「李登輝是日本的，釣魚台是台灣的！」(圖
取自黃智賢臉書)

李登輝訪日言行在兩岸激起一波波議論。作家黃智賢今日在臉書中表示，
「李登輝是日本的，釣魚臺是臺灣的！」黃智賢建議臺灣和日本舉行交接儀式，將李登輝正式移交給日本政府，永久託管供奉。
黃智賢指出，李登輝力挺安倍，說釣魚臺是日本的，還說要讓臺灣脫離中國法統, 其實就是把臺灣拉進日本的勢力。所以李登輝當然認為，臺籍慰安婦是自願的。所以日本殖民統治臺灣，是好的。所以日本侵略中國，也是好的。你還能期待一個日本右翼軍國主義信仰者，說出甚麼 ?
    黃智賢直指，李登輝其實是基於愛國主義，愛日本國。「做一個人，還能更
為日本賣命嗎 ?」「李登輝的賣國，是賣中華民國。」「李登輝，真是對日本忠貞，無愧於日本天皇的真日本人。」
黃智賢建議日本安倍政權，給予李登輝日本國籍，將他迎回日本，永保安康。黃智賢痛批，李登輝享盡了中華民國的榮華富貴，卻恨不能親眼看見中華民國亡。日本想亡中華民國，卻被拖住，差點亡國。李登輝一人功勞, 大過二戰的日本皇軍。
黃智賢說，「因為，岩里政男，本來就是日本的。而釣魚臺，是我們的。」「至於蔡英文，怎麼沒有人問她，1.她要維持的現狀，到底是有釣魚臺，還是沒有釣魚臺的現狀？2.她所說的，要繼續承擔責任的教科書，釣魚臺到底是誰的？
黃智賢臉書
出版編輯：任鳳儀
校正編輯：徐秀娥








--
William Tang (Chen Tang)

Posted by at No comments:

Fwd: 台灣笑話



Sent from my iPad

Begin forwarded message:

From: Dolores Kuo <doloresmkuo@gmail.com>
Date: July 28, 2015 at 1:39:56 PM CDT
To: "ronny_lin@hotmail.com" <ronny_lin@hotmail.com>, Chris Wang <chriswang_95051@yahoo.com>,  Tina Soong <tsoongtotherim@aol.com>, Charlotte Tao <charlottetao1@gmail.com>
Subject: Fwd: 台灣笑話



---------- Forwarded message ----------
From: Jensie Tou <pandjtou@aol.com>
Date: Tuesday, July 28, 2015
Subject: Fwd: 台灣笑話
To: Nancy Chao <nancyhychao@yahoo.com>, Dolores Kuo <doloresmkuo@gmail.com>




Sent from my iPad

Begin forwarded message:


Subject: Fwd: 台灣笑話



Sent from my iPad


Subject: Fwd: 台灣笑話













一天，一個女裁縫坐在河邊縫衣裳，一不小心她的頂針掉進河裡，她傷心得大哭起來。



聽到哭聲，上帝出現了 ........

上帝問道：「"我親愛的孩子，你為什麼哭泣啊？」

女裁縫告訴上帝事情的原委，並說她這枚頂針是她維持生活的工具。

上帝把手伸入水中摸出一枚鑲著珍珠的金頂針，問女裁縫：「這個頂針是你的嗎？」
「不是。」女裁縫回答。

上帝再次把手伸進水中摸出一枚鑲著玉石的銀頂針問：「這個頂針是你的嗎？」
「不是。」女裁縫搖了搖頭。

上帝第三次把手伸進水中摸出一個銅頂針，然後問：「這個頂針是你的嗎？」
女裁縫點點頭說：「是的。」

見這女裁縫很誠實，上帝很高興，就把三個頂針全給了她。 
 
         --------------------------------------

幾年後，女裁縫與她的丈夫在河邊散步，她的丈夫一失足掉進河裡，很快就沉沒在水中。女裁縫忙哭喊著叫救命。

上帝又出現了......
 
上帝問：「我的孩子，這次你又為什麼哭泣啊？」
「噢，上帝，我的丈夫掉進河裡！」

上帝跳進水中撈出一個人，是大明星喬治克魯尼（George Clooney），然後問：「這是你的丈夫嗎？」
「是的。」女裁縫哭泣著回答。

「你撒謊！他並不是你的丈夫！」上帝憤怒了。 

女裁縫慌忙說道：「噢，上帝，請原諒我，我撒謊是迫不得已的。如果我說喬治克魯尼不是我的丈夫，您又會從水中撈出布萊德彼特（Brad Pitt），我再說不是，您才會撈出我的丈夫，最後我說是，您又會把這三個男人全都給我。您看，我的身體並不強壯，如果讓我伺候三個丈夫的話，我會累死的。」

上帝聽了覺得還滿有道理，就原諒了女裁縫的謊言，把他丈夫救回了岸上。

忽然間 .......... 丈夫把女裁縫推入了水中，並跟上帝說：「來吧，我平日有在鍛鍊身體，我夠強壯！」 

上帝真的給了他三個女人：

黃睿靚──陳水扁的媳婦 
陳幸妤──陳水扁的女兒 
吳淑珍──陳水扁的老婆

他丈夫馬上跳進河裡救他妻子去了。





--
Sent from my iPad
Posted by at No comments:
Subscribe to: Posts (Atom)